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


#ifndef SWIGCSHARP
#define SWIGCSHARP
#endif

#define SWIG_DIRECTORS


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


/* Support for throwing C# exceptions from C/C++. There are two types: 
 * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
typedef enum {
  SWIG_CSharpApplicationException,
  SWIG_CSharpArithmeticException,
  SWIG_CSharpDivideByZeroException,
  SWIG_CSharpIndexOutOfRangeException,
  SWIG_CSharpInvalidCastException,
  SWIG_CSharpInvalidOperationException,
  SWIG_CSharpIOException,
  SWIG_CSharpNullReferenceException,
  SWIG_CSharpOutOfMemoryException,
  SWIG_CSharpOverflowException,
  SWIG_CSharpSystemException
} SWIG_CSharpExceptionCodes;

typedef enum {
  SWIG_CSharpArgumentException,
  SWIG_CSharpArgumentNullException,
  SWIG_CSharpArgumentOutOfRangeException
} SWIG_CSharpExceptionArgumentCodes;

typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);

typedef struct {
  SWIG_CSharpExceptionCodes code;
  SWIG_CSharpExceptionCallback_t callback;
} SWIG_CSharpException_t;

typedef struct {
  SWIG_CSharpExceptionArgumentCodes code;
  SWIG_CSharpExceptionArgumentCallback_t callback;
} SWIG_CSharpExceptionArgument_t;

static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
  { SWIG_CSharpApplicationException, NULL },
  { SWIG_CSharpArithmeticException, NULL },
  { SWIG_CSharpDivideByZeroException, NULL },
  { SWIG_CSharpIndexOutOfRangeException, NULL },
  { SWIG_CSharpInvalidCastException, NULL },
  { SWIG_CSharpInvalidOperationException, NULL },
  { SWIG_CSharpIOException, NULL },
  { SWIG_CSharpNullReferenceException, NULL },
  { SWIG_CSharpOutOfMemoryException, NULL },
  { SWIG_CSharpOverflowException, NULL },
  { SWIG_CSharpSystemException, NULL }
};

static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
  { SWIG_CSharpArgumentException, NULL },
  { SWIG_CSharpArgumentNullException, NULL },
  { SWIG_CSharpArgumentOutOfRangeException, NULL }
};

static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
    callback = SWIG_csharp_exceptions[code].callback;
  }
  callback(msg);
}

static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
    callback = SWIG_csharp_exceptions_argument[code].callback;
  }
  callback(msg, param_name);
}


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NQuantLibc(
                                                SWIG_CSharpExceptionCallback_t applicationCallback,
                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
                                                SWIG_CSharpExceptionCallback_t invalidCastCallback,
                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
                                                SWIG_CSharpExceptionCallback_t ioCallback,
                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
                                                SWIG_CSharpExceptionCallback_t systemCallback) {
  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
}

#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NQuantLibc(
                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
}


/* Callback for returning strings to C# without leaking memory */
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NQuantLibc(SWIG_CSharpStringHelperCallback callback) {
  SWIG_csharp_string_callback = callback;
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else

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



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

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that C# proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#if defined(DEBUG_DIRECTOR_OWNED)
#include <iostream>
#endif
#include <string>
#include <exception>

namespace Swig {
  /* Director base class - not currently used in C# directors */
  class Director {
  };

  /* Base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;

  public:
    DirectorException(const char *msg) : swig_msg(msg) {
    }

    DirectorException(const std::string &msg) : swig_msg(msg) {
    }

    virtual ~DirectorException() throw() {
    }

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

  /* Pure virtual method exception */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
    }
  };
}


SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
  if (code == SWIG_ValueError) {
    SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
    SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
  } else {
    SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
    switch(code) {
    case SWIG_MemoryError:
      exception_code = SWIG_CSharpOutOfMemoryException;
      break;
    case SWIG_IndexError:
      exception_code = SWIG_CSharpIndexOutOfRangeException;
      break;
    case SWIG_DivisionByZero:
      exception_code = SWIG_CSharpDivideByZeroException;
      break;
    case SWIG_IOError:
      exception_code = SWIG_CSharpIOException;
      break;
    case SWIG_OverflowError:
      exception_code = SWIG_CSharpOverflowException;
      break;
    case SWIG_RuntimeError:
    case SWIG_TypeError:
    case SWIG_SyntaxError:
    case SWIG_SystemError:
    case SWIG_UnknownError:
    default:
      exception_code = SWIG_CSharpApplicationException;
      break;
    }
    SWIG_CSharpSetPendingException(exception_code, msg);
  }
}


#include <typeinfo>
#include <stdexcept>


#include <ql/quantlib.hpp>

#if QL_HEX_VERSION < 0x011200f0
    #error using an old version of QuantLib, please update
#endif

#ifdef BOOST_MSVC
#ifdef QL_ENABLE_THREAD_SAFE_OBSERVER_PATTERN
#define BOOST_LIB_NAME boost_thread
#include <boost/config/auto_link.hpp>
#undef BOOST_LIB_NAME
#define BOOST_LIB_NAME boost_system
#include <boost/config/auto_link.hpp>
#undef BOOST_LIB_NAME
#endif
#endif

#if defined (SWIGJAVA) || defined (SWIGCSHARP) 
  #ifndef QL_ENABLE_THREAD_SAFE_OBSERVER_PATTERN
    #ifdef BOOST_MSVC
      #pragma message(\
          "Quantlib has not been compiled with the thread-safe "           \
          "observer pattern being enabled. This can lead to spurious "     \
          "crashes or pure virtual function call within the JVM or .NET "  \
          "ecosystem due to the async garbage collector. Please consider " \
          "enabling QL_ENABLE_THREAD_SAFE_OBSERVER_PATTERN "               \
          "in ql/userconfig.hpp.")
    #else
      #warning \
          Quantlib has not been compiled with the thread-safe           \
          observer pattern being enabled. This can lead to spurious     \
          crashes or pure virtual function call within the JVM or .NET  \
          ecosystem due to the async garbage collector. Please consider \
          passing --enable-thread-safe-observer-pattern when using the  \
          GNU autoconf configure script.
    #endif
  #endif
#endif


// add here SWIG version check

#if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
// disable Swig-dependent warnings

// 'identifier1' has C-linkage specified,
// but returns UDT 'identifier2' which is incompatible with C
#pragma warning(disable: 4190)

// 'int' : forcing value to bool 'true' or 'false' (performance warning)
#pragma warning(disable: 4800)

// debug info too long etc etc
#pragma warning(disable: 4786)
#endif


#include <typeinfo>
#include <stdexcept>


#include <string>


#include <vector>
#include <algorithm>
#include <stdexcept>


#include <map>
#include <algorithm>
#include <stdexcept>


#include <utility>


// This is necessary to avoid compile failures on 
// GCC 4
// see http://svn.boost.org/trac/boost/ticket/1793

#if defined(NDEBUG)
#define BOOST_DISABLE_ASSERTS 1
#endif

#include <boost/algorithm/string/case_conv.hpp>


// generally useful classes
using QuantLib::Error;
using QuantLib::Handle;
using QuantLib::RelinkableHandle;


using QuantLib::Integer;
using QuantLib::BigInteger;
using QuantLib::Natural;
using QuantLib::BigNatural;
using QuantLib::Real;
using QuantLib::Decimal;
using QuantLib::Time;
using QuantLib::Rate;
using QuantLib::Spread;
using QuantLib::DiscountFactor;
using QuantLib::Volatility;
using QuantLib::Probability;
using QuantLib::Size;


#ifndef QL_HIGH_RESOLUTION_DATE
    // They are not defined in the library, so we define them here
    namespace QuantLib {
        typedef int Hour;
        typedef int Minute;
        typedef int Second;
        typedef int Millisecond;
        typedef int Microsecond;
    }
#endif

using QuantLib::Day;
using QuantLib::Year;
using QuantLib::Hour;
using QuantLib::Minute;
using QuantLib::Second;
using QuantLib::Millisecond;
using QuantLib::Microsecond;


using QuantLib::Weekday;
using QuantLib::Sunday;
using QuantLib::Monday;
using QuantLib::Tuesday;
using QuantLib::Wednesday;
using QuantLib::Thursday;
using QuantLib::Friday;
using QuantLib::Saturday;


using QuantLib::Month;
using QuantLib::January;
using QuantLib::February;
using QuantLib::March;
using QuantLib::April;
using QuantLib::May;
using QuantLib::June;
using QuantLib::July;
using QuantLib::August;
using QuantLib::September;
using QuantLib::October;
using QuantLib::November;
using QuantLib::December;


using QuantLib::TimeUnit;
using QuantLib::Days;
using QuantLib::Weeks;
using QuantLib::Months;
using QuantLib::Years;
using QuantLib::Hours;
using QuantLib::Minutes;
using QuantLib::Seconds;
using QuantLib::Milliseconds;
using QuantLib::Microseconds;


using QuantLib::Frequency;
using QuantLib::NoFrequency;
using QuantLib::Once;
using QuantLib::Annual;
using QuantLib::Semiannual;
using QuantLib::EveryFourthMonth;
using QuantLib::Quarterly;
using QuantLib::Bimonthly;
using QuantLib::Monthly;
using QuantLib::EveryFourthWeek;
using QuantLib::Biweekly;
using QuantLib::Weekly;
using QuantLib::Daily;
using QuantLib::OtherFrequency;


using QuantLib::Period;
using QuantLib::PeriodParser;

SWIGINTERN Period *new_Period__SWIG_3(std::string const &str){
            return new Period(PeriodParser::parse(str));
        }
SWIGINTERN std::string Period___str__(Period *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }
SWIGINTERN std::string Period___repr__(Period *self){
            std::ostringstream out;
            out << "Period(\"" << QuantLib::io::short_period(*self) << "\")";
            return out.str();
        }
SWIGINTERN std::vector< Period > *new_std_vector_Sl_Period_Sg___SWIG_2(int capacity){
        std::vector< Period >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< Period >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN Period std_vector_Sl_Period_Sg__getitemcopy(std::vector< Period > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN Period const &std_vector_Sl_Period_Sg__getitem(std::vector< Period > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Period_Sg__setitem(std::vector< Period > *self,int index,Period const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Period_Sg__AddRange(std::vector< Period > *self,std::vector< Period > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< Period > *std_vector_Sl_Period_Sg__GetRange(std::vector< Period > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< Period >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_Period_Sg__Insert(std::vector< Period > *self,int index,Period const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Period_Sg__InsertRange(std::vector< Period > *self,int index,std::vector< Period > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Period_Sg__RemoveAt(std::vector< Period > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Period_Sg__RemoveRange(std::vector< Period > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< Period > *std_vector_Sl_Period_Sg__Repeat(Period const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< Period >(count, value);
      }
SWIGINTERN void std_vector_Sl_Period_Sg__Reverse__SWIG_0(std::vector< Period > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_Period_Sg__Reverse__SWIG_1(std::vector< Period > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_Period_Sg__SetRange(std::vector< Period > *self,int index,std::vector< Period > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }

using QuantLib::Date;
using QuantLib::DateParser;


    // used in Date(string, string) defined below
    void _replace_format(std::string& s, const std::string& old_format,
                         const std::string& new_format) {
        std::string::size_type i = s.find(old_format);
        if (i != std::string::npos)
            s.replace(i, old_format.length(), new_format);
    }

SWIGINTERN Date *new_Date__SWIG_2(Day d,Month m,Year y,Hour hours,Minute minutes,Second seconds,Millisecond millisec=0,Microsecond microsec=0){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return new Date(d, m, y, hours, minutes, seconds,
                            millisec, microsec);
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Hour Date_hours(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->hours();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Minute Date_minutes(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->minutes();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Second Date_seconds(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->seconds();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Millisecond Date_milliseconds(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->milliseconds();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Microsecond Date_microseconds(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->microseconds();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Time Date_fractionOfDay(Date const *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->fractionOfDay();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Time Date_fractionOfSecond(Date const *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->fractionOfSecond();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Date Date_localDateTime(){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return Date::localDateTime();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Date Date_universalDateTime(){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return Date::universalDateTime();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
         }
SWIGINTERN Date *new_Date__SWIG_6(std::string const &str,std::string fmt){
            // convert our old format into the corresponding Boost one
            _replace_format(fmt, "YYYY", "%Y");
            _replace_format(fmt, "yyyy", "%Y");
            _replace_format(fmt, "YY", "%y");
            _replace_format(fmt, "yy", "%y");
            _replace_format(fmt, "MM", "%m");
            _replace_format(fmt, "mm", "%m");
            _replace_format(fmt, "DD", "%d");
            _replace_format(fmt, "dd", "%d");
            return new Date(DateParser::parseFormatted(str,fmt));
        }
SWIGINTERN Integer Date_weekdayNumber(Date *self){
            return int(self->weekday());
        }
SWIGINTERN std::string Date___str__(Date *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }
SWIGINTERN std::string Date___repr__(Date *self){
            std::ostringstream out;
            if (*self == Date())
                out << "Date()";
            else
                out << "Date(" << self->dayOfMonth() << ","
                    << int(self->month()) << "," << self->year() << ")";
            return out.str();
        }
SWIGINTERN std::string Date_ISO(Date *self){
            std::ostringstream out;
            out << QuantLib::io::iso_date(*self);
            return out.str();
        }
SWIGINTERN Date DateParser_parse(std::string const &str,std::string fmt){
            // convert our old format into the corresponding Boost one
            _replace_format(fmt, "YYYY", "%Y");
            _replace_format(fmt, "yyyy", "%Y");
            _replace_format(fmt, "YY", "%y");
            _replace_format(fmt, "yy", "%y");
            _replace_format(fmt, "MM", "%m");
            _replace_format(fmt, "mm", "%m");
            _replace_format(fmt, "DD", "%d");
            _replace_format(fmt, "dd", "%d");
            return DateParser::parseFormatted(str,fmt);
        }
SWIGINTERN std::vector< Date > *new_std_vector_Sl_Date_Sg___SWIG_2(int capacity){
        std::vector< Date >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< Date >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN Date std_vector_Sl_Date_Sg__getitemcopy(std::vector< Date > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN Date const &std_vector_Sl_Date_Sg__getitem(std::vector< Date > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Date_Sg__setitem(std::vector< Date > *self,int index,Date const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Date_Sg__AddRange(std::vector< Date > *self,std::vector< Date > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< Date > *std_vector_Sl_Date_Sg__GetRange(std::vector< Date > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< Date >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_Date_Sg__Insert(std::vector< Date > *self,int index,Date const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Date_Sg__InsertRange(std::vector< Date > *self,int index,std::vector< Date > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Date_Sg__RemoveAt(std::vector< Date > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Date_Sg__RemoveRange(std::vector< Date > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< Date > *std_vector_Sl_Date_Sg__Repeat(Date const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< Date >(count, value);
      }
SWIGINTERN void std_vector_Sl_Date_Sg__Reverse__SWIG_0(std::vector< Date > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_Date_Sg__Reverse__SWIG_1(std::vector< Date > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_Date_Sg__SetRange(std::vector< Date > *self,int index,std::vector< Date > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }

using QuantLib::IMM;


using QuantLib::ASX;

SWIGINTERN std::vector< int > *new_std_vector_Sl_int_Sg___SWIG_2(int capacity){
        std::vector< int >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< int >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN int std_vector_Sl_int_Sg__getitemcopy(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN int const &std_vector_Sl_int_Sg__getitem(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__setitem(std::vector< int > *self,int index,int const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__AddRange(std::vector< int > *self,std::vector< int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__GetRange(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< int >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int_Sg__Insert(std::vector< int > *self,int index,int const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__InsertRange(std::vector< int > *self,int index,std::vector< int > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__RemoveAt(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__RemoveRange(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__Repeat(int const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< int >(count, value);
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_0(std::vector< int > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_1(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int_Sg__SetRange(std::vector< int > *self,int index,std::vector< int > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_int_Sg__Contains(std::vector< int > *self,int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int_Sg__IndexOf(std::vector< int > *self,int const &value){
        int index = -1;
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_int_Sg__LastIndexOf(std::vector< int > *self,int const &value){
        int index = -1;
        std::vector< int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_int_Sg__Remove(std::vector< int > *self,int const &value){
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
        std::vector< unsigned int >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< unsigned int >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< unsigned int >(count, value);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
        int index = -1;
        std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
        int index = -1;
        std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
        std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< double > *new_std_vector_Sl_double_Sg___SWIG_2(int capacity){
        std::vector< double >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< double >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN double std_vector_Sl_double_Sg__getitemcopy(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN double const &std_vector_Sl_double_Sg__getitem(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__setitem(std::vector< double > *self,int index,double const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__AddRange(std::vector< double > *self,std::vector< double > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__GetRange(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< double >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_double_Sg__Insert(std::vector< double > *self,int index,double const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__InsertRange(std::vector< double > *self,int index,std::vector< double > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__RemoveAt(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__RemoveRange(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__Repeat(double const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< double >(count, value);
      }
SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_0(std::vector< double > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_1(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_double_Sg__SetRange(std::vector< double > *self,int index,std::vector< double > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_double_Sg__Contains(std::vector< double > *self,double const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_double_Sg__IndexOf(std::vector< double > *self,double const &value){
        int index = -1;
        std::vector< double >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_double_Sg__LastIndexOf(std::vector< double > *self,double const &value){
        int index = -1;
        std::vector< double >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_double_Sg__Remove(std::vector< double > *self,double const &value){
        std::vector< double >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::string > *new_std_vector_Sl_std_string_Sg___SWIG_2(int capacity){
        std::vector< std::string >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::string >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::string std_vector_Sl_std_string_Sg__getitemcopy(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::string const &std_vector_Sl_std_string_Sg__getitem(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__setitem(std::vector< std::string > *self,int index,std::string const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__AddRange(std::vector< std::string > *self,std::vector< std::string > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::string > *std_vector_Sl_std_string_Sg__GetRange(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::string >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Insert(std::vector< std::string > *self,int index,std::string const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__InsertRange(std::vector< std::string > *self,int index,std::vector< std::string > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__RemoveAt(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__RemoveRange(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::string > *std_vector_Sl_std_string_Sg__Repeat(std::string const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::string >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Reverse__SWIG_0(std::vector< std::string > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Reverse__SWIG_1(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__SetRange(std::vector< std::string > *self,int index,std::vector< std::string > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_std_string_Sg__Contains(std::vector< std::string > *self,std::string const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_std_string_Sg__IndexOf(std::vector< std::string > *self,std::string const &value){
        int index = -1;
        std::vector< std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_std_string_Sg__LastIndexOf(std::vector< std::string > *self,std::string const &value){
        int index = -1;
        std::vector< std::string >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_std_string_Sg__Remove(std::vector< std::string > *self,std::string const &value){
        std::vector< std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< bool > *new_std_vector_Sl_bool_Sg___SWIG_2(int capacity){
        std::vector< bool >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< bool >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN bool std_vector_Sl_bool_Sg__getitemcopy(std::vector< bool > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN bool std_vector_Sl_bool_Sg__getitem(std::vector< bool > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_bool_Sg__setitem(std::vector< bool > *self,int index,bool const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_bool_Sg__AddRange(std::vector< bool > *self,std::vector< bool > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< bool > *std_vector_Sl_bool_Sg__GetRange(std::vector< bool > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< bool >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_bool_Sg__Insert(std::vector< bool > *self,int index,bool const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_bool_Sg__InsertRange(std::vector< bool > *self,int index,std::vector< bool > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_bool_Sg__RemoveAt(std::vector< bool > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_bool_Sg__RemoveRange(std::vector< bool > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< bool > *std_vector_Sl_bool_Sg__Repeat(bool const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< bool >(count, value);
      }
SWIGINTERN void std_vector_Sl_bool_Sg__Reverse__SWIG_0(std::vector< bool > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_bool_Sg__Reverse__SWIG_1(std::vector< bool > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_bool_Sg__SetRange(std::vector< bool > *self,int index,std::vector< bool > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_bool_Sg__Contains(std::vector< bool > *self,bool const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_bool_Sg__IndexOf(std::vector< bool > *self,bool const &value){
        int index = -1;
        std::vector< bool >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_bool_Sg__LastIndexOf(std::vector< bool > *self,bool const &value){
        int index = -1;
        std::vector< bool >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_bool_Sg__Remove(std::vector< bool > *self,bool const &value){
        std::vector< bool >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::pair< Date,double > > *new_std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::pair<Date,double> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::pair<Date,double> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::pair< Date,double > std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__getitemcopy(std::vector< std::pair< Date,double > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::pair< Date,double > const &std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__getitem(std::vector< std::pair< Date,double > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__setitem(std::vector< std::pair< Date,double > > *self,int index,std::pair< Date,double > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__AddRange(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::pair< Date,double > > *std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__GetRange(std::vector< std::pair< Date,double > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::pair<Date,double> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Insert(std::vector< std::pair< Date,double > > *self,int index,std::pair< Date,double > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__InsertRange(std::vector< std::pair< Date,double > > *self,int index,std::vector< std::pair< Date,double > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__RemoveAt(std::vector< std::pair< Date,double > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__RemoveRange(std::vector< std::pair< Date,double > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::pair< Date,double > > *std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Repeat(std::pair< Date,double > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::pair<Date,double> >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< Date,double > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< Date,double > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__SetRange(std::vector< std::pair< Date,double > > *self,int index,std::vector< std::pair< Date,double > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Contains(std::vector< std::pair< Date,double > > *self,std::pair< Date,double > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__IndexOf(std::vector< std::pair< Date,double > > *self,std::pair< Date,double > const &value){
        int index = -1;
        std::vector< std::pair<Date,double> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__LastIndexOf(std::vector< std::pair< Date,double > > *self,std::pair< Date,double > const &value){
        int index = -1;
        std::vector< std::pair<Date,double> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Remove(std::vector< std::pair< Date,double > > *self,std::pair< Date,double > const &value){
        std::vector< std::pair<Date,double> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

using QuantLib::Exercise;

SWIGINTERN bool boost_shared_ptr_Sl_Exercise_Sg__isNull(boost::shared_ptr< Exercise > *self){
                return !(*self);
            }
SWIGINTERN Exercise::Type boost_shared_ptr_Sl_Exercise_Sg__exerciseType(boost::shared_ptr< Exercise > *self){ 
		return boost::dynamic_pointer_cast<Exercise>(*self)->type(); 
	}

using QuantLib::EuropeanExercise;
using QuantLib::AmericanExercise;
using QuantLib::BermudanExercise;
using QuantLib::RebatedExercise;
typedef boost::shared_ptr<Exercise> EuropeanExercisePtr;
typedef boost::shared_ptr<Exercise> AmericanExercisePtr;
typedef boost::shared_ptr<Exercise> BermudanExercisePtr;
typedef boost::shared_ptr<Exercise> RebatedExercisePtr;

SWIGINTERN EuropeanExercisePtr *new_EuropeanExercisePtr(Date const &date){
            return new EuropeanExercisePtr(new EuropeanExercise(date));
        }
SWIGINTERN AmericanExercisePtr *new_AmericanExercisePtr__SWIG_0(Date const &earliestDate,Date const &latestDate,bool payoffAtExpiry=false){
            return new AmericanExercisePtr(
                                        new AmericanExercise(earliestDate,
                                                             latestDate,
                                                             payoffAtExpiry));

        }
SWIGINTERN BermudanExercisePtr *new_BermudanExercisePtr__SWIG_0(std::vector< Date > const &dates,bool payoffAtExpiry=false){
            return new BermudanExercisePtr(
                                        new BermudanExercise(dates,
                                                             payoffAtExpiry));
        }

using QuantLib::BusinessDayConvention;
using QuantLib::Calendar;
using QuantLib::Following;
using QuantLib::NullCalendar;

SWIGINTERN RebatedExercisePtr *new_RebatedExercisePtr__SWIG_0(boost::shared_ptr< Exercise > const exercise,std::vector< Real > const rebates,Natural rebateSettlementDays=0,Calendar const &rebatePaymentCalendar=NullCalendar(),BusinessDayConvention const rebatePaymentConvention=Following){
            return new RebatedExercisePtr(new RebatedExercise(*exercise, rebates,
                                                              rebateSettlementDays,
                                                              rebatePaymentCalendar,
                                                              rebatePaymentConvention));
        }

using QuantLib::Observer;
using QuantLib::Observable;

SWIGINTERN bool boost_shared_ptr_Sl_Observable_Sg__isNull(boost::shared_ptr< Observable > *self){
                return !(*self);
            }

using QuantLib::Array;
using QuantLib::Matrix;
using QuantLib::SampledCurve;

SWIGINTERN std::string Array___str__(Array *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }
SWIGINTERN Real Array_get(Array *self,Size i){
            if (i<self->size())
                return (*self)[i];
            else
                throw std::out_of_range("array index out of range");
        }
SWIGINTERN void Array_set(Array *self,Size i,Real x){
            if (i<self->size())
                (*self)[i] = x;
            else
                throw std::out_of_range("array index out of range");
        }

typedef QuantLib::LexicographicalView<Array::iterator>
    DefaultLexicographicalView;
typedef QuantLib::LexicographicalView<Array::iterator>::y_iterator
    DefaultLexicographicalViewColumn;

SWIGINTERN DefaultLexicographicalView *new_DefaultLexicographicalView(Array &a,Size xSize){
            return new DefaultLexicographicalView(a.begin(),a.end(),xSize);
        }
SWIGINTERN std::string DefaultLexicographicalView___str__(DefaultLexicographicalView *self){
            std::ostringstream s;
            for (Size j=0; j<self->ySize(); j++) {
                s << "\n";
                for (Size i=0; i<self->xSize(); i++) {
                    if (i != 0)
                        s << ",";
                    Array::value_type value = (*self)[i][j];
                    s << value;
                }
            }
            s << "\n";
            return s.str();
        }

typedef QuantLib::Matrix::row_iterator MatrixRow;
using QuantLib::outerProduct;
using QuantLib::transpose;
using QuantLib::SVD;

SWIGINTERN std::string Matrix___str__(Matrix *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }
SWIGINTERN Real Matrix_get(Matrix *self,Size i,Size j){
            return (*self)[i][j];
        }
SWIGINTERN void Matrix_set(Matrix *self,Size i,Size j,Real x){
            (*self)[i][j] = x;
        }

using QuantLib::pseudoSqrt;
using QuantLib::SalvagingAlgorithm;


using QuantLib::CostFunction;
using QuantLib::Disposable;


class UnaryFunctionDelegate {
  public:
    virtual ~UnaryFunctionDelegate() {}
    virtual Real value(Real x) const {
        QL_FAIL("implementation of UnaryFunctionDelegate.value is missing");
    };
};

class UnaryFunction : public std::unary_function<Real, Real> {
  public:
    UnaryFunction(UnaryFunctionDelegate* delegate)
    : delegate_(delegate) { }

    virtual ~UnaryFunction() { }

    Real operator()(Real x) const {
        return delegate_->value(x);
    }

  private:
    UnaryFunctionDelegate* delegate_;
};


class CostFunctionDelegate {
  public:
    virtual ~CostFunctionDelegate() {}
    virtual Real value(const Array& x) const {
      QL_FAIL("implementation of CostFunctionDelegate.value is missing");
    }

    virtual Array values(const Array& x) const {
      QL_FAIL("implementation of CostFunctionDelegate.values is missing");
    }
};

class DotNetCostFunction : public CostFunction {
  public:
    DotNetCostFunction(CostFunctionDelegate* delegate)
    : delegate_(delegate) { }

    virtual ~DotNetCostFunction(){ }

    virtual Real value(const Array& x ) const{
      return delegate_->value(x);
    }

    virtual Disposable<Array> values(const Array& x) const {
      Array retVal = delegate_->values(x);
      return retVal;
    }

  private:
    CostFunctionDelegate* delegate_;
};


using QuantLib::Quote;

SWIGINTERN bool boost_shared_ptr_Sl_Quote_Sg__isNull(boost::shared_ptr< Quote > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_Quote_Sg__asObservable(boost::shared_ptr< Quote > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_Quote_Sg__asObservable(Handle< Quote > *self){
        return boost::shared_ptr<Observable>(*self);
    }

using QuantLib::SimpleQuote;
typedef boost::shared_ptr<Quote> SimpleQuotePtr;

SWIGINTERN SimpleQuotePtr *new_SimpleQuotePtr(Real value){
            return new SimpleQuotePtr(new SimpleQuote(value));
        }
SWIGINTERN void SimpleQuotePtr_setValue(SimpleQuotePtr *self,Real value){
            boost::dynamic_pointer_cast<SimpleQuote>(*self)->setValue(value);
        }
SWIGINTERN std::vector< boost::shared_ptr< Quote > > *new_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<Quote> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<Quote> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< Quote > std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< Quote > const &std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__getitem(std::vector< boost::shared_ptr< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__setitem(std::vector< boost::shared_ptr< Quote > > *self,int index,boost::shared_ptr< Quote > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__AddRange(std::vector< boost::shared_ptr< Quote > > *self,std::vector< boost::shared_ptr< Quote > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< Quote > > *std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__GetRange(std::vector< boost::shared_ptr< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<Quote> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Insert(std::vector< boost::shared_ptr< Quote > > *self,int index,boost::shared_ptr< Quote > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< Quote > > *self,int index,std::vector< boost::shared_ptr< Quote > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< Quote > > *std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Repeat(boost::shared_ptr< Quote > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<Quote> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< Quote > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__SetRange(std::vector< boost::shared_ptr< Quote > > *self,int index,std::vector< boost::shared_ptr< Quote > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Contains(std::vector< boost::shared_ptr< Quote > > *self,boost::shared_ptr< Quote > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< Quote > > *self,boost::shared_ptr< Quote > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<Quote> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< Quote > > *self,boost::shared_ptr< Quote > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<Quote> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Remove(std::vector< boost::shared_ptr< Quote > > *self,boost::shared_ptr< Quote > const &value){
        std::vector< boost::shared_ptr<Quote> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::vector< boost::shared_ptr< Quote > > > *new_std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< boost::shared_ptr< Quote > > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< boost::shared_ptr< Quote > > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< boost::shared_ptr< Quote > > std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__getitemcopy(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< Quote > > const &std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__getitem(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__setitem(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index,std::vector< boost::shared_ptr< Quote > > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__AddRange(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,std::vector< std::vector< boost::shared_ptr< Quote > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< boost::shared_ptr< Quote > > > *std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__GetRange(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< boost::shared_ptr< Quote > > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__Insert(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index,std::vector< boost::shared_ptr< Quote > > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__InsertRange(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index,std::vector< std::vector< boost::shared_ptr< Quote > > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__RemoveAt(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__RemoveRange(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< boost::shared_ptr< Quote > > > *std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__Repeat(std::vector< boost::shared_ptr< Quote > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< boost::shared_ptr< Quote > > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< boost::shared_ptr< Quote > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__SetRange(std::vector< std::vector< boost::shared_ptr< Quote > > > *self,int index,std::vector< std::vector< boost::shared_ptr< Quote > > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< Handle< Quote > > *new_std_vector_Sl_Handle_Sl_Quote_Sg__Sg___SWIG_2(int capacity){
        std::vector< Handle<Quote> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< Handle<Quote> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN Handle< Quote > std_vector_Sl_Handle_Sl_Quote_Sg__Sg__getitemcopy(std::vector< Handle< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN Handle< Quote > const &std_vector_Sl_Handle_Sl_Quote_Sg__Sg__getitem(std::vector< Handle< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__setitem(std::vector< Handle< Quote > > *self,int index,Handle< Quote > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__AddRange(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< Handle< Quote > > *std_vector_Sl_Handle_Sl_Quote_Sg__Sg__GetRange(std::vector< Handle< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< Handle<Quote> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Insert(std::vector< Handle< Quote > > *self,int index,Handle< Quote > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__InsertRange(std::vector< Handle< Quote > > *self,int index,std::vector< Handle< Quote > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__RemoveAt(std::vector< Handle< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__RemoveRange(std::vector< Handle< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< Handle< Quote > > *std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Repeat(Handle< Quote > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< Handle<Quote> >(count, value);
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Reverse__SWIG_0(std::vector< Handle< Quote > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Reverse__SWIG_1(std::vector< Handle< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__SetRange(std::vector< Handle< Quote > > *self,int index,std::vector< Handle< Quote > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Contains(std::vector< Handle< Quote > > *self,Handle< Quote > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_Handle_Sl_Quote_Sg__Sg__IndexOf(std::vector< Handle< Quote > > *self,Handle< Quote > const &value){
        int index = -1;
        std::vector< Handle<Quote> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_Handle_Sl_Quote_Sg__Sg__LastIndexOf(std::vector< Handle< Quote > > *self,Handle< Quote > const &value){
        int index = -1;
        std::vector< Handle<Quote> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Remove(std::vector< Handle< Quote > > *self,Handle< Quote > const &value){
        std::vector< Handle<Quote> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::vector< Handle< Quote > > > *new_std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< Handle< Quote > > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< Handle< Quote > > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< Handle< Quote > > std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__getitemcopy(std::vector< std::vector< Handle< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< Handle< Quote > > const &std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__getitem(std::vector< std::vector< Handle< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__setitem(std::vector< std::vector< Handle< Quote > > > *self,int index,std::vector< Handle< Quote > > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__AddRange(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< Handle< Quote > > > *std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__GetRange(std::vector< std::vector< Handle< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< Handle< Quote > > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__Insert(std::vector< std::vector< Handle< Quote > > > *self,int index,std::vector< Handle< Quote > > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__InsertRange(std::vector< std::vector< Handle< Quote > > > *self,int index,std::vector< std::vector< Handle< Quote > > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__RemoveAt(std::vector< std::vector< Handle< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__RemoveRange(std::vector< std::vector< Handle< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< Handle< Quote > > > *std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__Repeat(std::vector< Handle< Quote > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< Handle< Quote > > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< Handle< Quote > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< Handle< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__SetRange(std::vector< std::vector< Handle< Quote > > > *self,int index,std::vector< std::vector< Handle< Quote > > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< RelinkableHandle< Quote > > *new_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg___SWIG_2(int capacity){
        std::vector< RelinkableHandle<Quote> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RelinkableHandle<Quote> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RelinkableHandle< Quote > std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__getitemcopy(std::vector< RelinkableHandle< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN RelinkableHandle< Quote > const &std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__getitem(std::vector< RelinkableHandle< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__setitem(std::vector< RelinkableHandle< Quote > > *self,int index,RelinkableHandle< Quote > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__AddRange(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RelinkableHandle< Quote > > *std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__GetRange(std::vector< RelinkableHandle< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RelinkableHandle<Quote> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Insert(std::vector< RelinkableHandle< Quote > > *self,int index,RelinkableHandle< Quote > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__InsertRange(std::vector< RelinkableHandle< Quote > > *self,int index,std::vector< RelinkableHandle< Quote > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__RemoveAt(std::vector< RelinkableHandle< Quote > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__RemoveRange(std::vector< RelinkableHandle< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RelinkableHandle< Quote > > *std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Repeat(RelinkableHandle< Quote > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RelinkableHandle<Quote> >(count, value);
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Reverse__SWIG_0(std::vector< RelinkableHandle< Quote > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Reverse__SWIG_1(std::vector< RelinkableHandle< Quote > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__SetRange(std::vector< RelinkableHandle< Quote > > *self,int index,std::vector< RelinkableHandle< Quote > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Contains(std::vector< RelinkableHandle< Quote > > *self,RelinkableHandle< Quote > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__IndexOf(std::vector< RelinkableHandle< Quote > > *self,RelinkableHandle< Quote > const &value){
        int index = -1;
        std::vector< RelinkableHandle<Quote> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__LastIndexOf(std::vector< RelinkableHandle< Quote > > *self,RelinkableHandle< Quote > const &value){
        int index = -1;
        std::vector< RelinkableHandle<Quote> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Remove(std::vector< RelinkableHandle< Quote > > *self,RelinkableHandle< Quote > const &value){
        std::vector< RelinkableHandle<Quote> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > > *new_std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< RelinkableHandle< Quote > > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< RelinkableHandle< Quote > > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< RelinkableHandle< Quote > > std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__getitemcopy(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RelinkableHandle< Quote > > const &std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__getitem(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__setitem(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index,std::vector< RelinkableHandle< Quote > > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__AddRange(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > > *std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__GetRange(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< RelinkableHandle< Quote > > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__Insert(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index,std::vector< RelinkableHandle< Quote > > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__InsertRange(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index,std::vector< std::vector< RelinkableHandle< Quote > > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__RemoveAt(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__RemoveRange(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > > *std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__Repeat(std::vector< RelinkableHandle< Quote > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< RelinkableHandle< Quote > > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< RelinkableHandle< Quote > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__SetRange(std::vector< std::vector< RelinkableHandle< Quote > > > *self,int index,std::vector< std::vector< RelinkableHandle< Quote > > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }

using QuantLib::Calendar;


using QuantLib::BusinessDayConvention;
using QuantLib::Following;
using QuantLib::ModifiedFollowing;
using QuantLib::Preceding;
using QuantLib::ModifiedPreceding;
using QuantLib::Unadjusted;
using QuantLib::HalfMonthModifiedFollowing;


using QuantLib::JointCalendarRule;
using QuantLib::JoinHolidays;
using QuantLib::JoinBusinessDays;

SWIGINTERN std::string Calendar___str__(Calendar *self){
            return self->name()+" calendar";
        }

using QuantLib::Null;
typedef int intOrNull;
typedef double doubleOrNull;


int nullInt() { return Null<int>(); }
double nullDouble() { return Null<double>(); }


using QuantLib::DayCounter;

SWIGINTERN std::string DayCounter___str__(DayCounter *self){
            return self->name()+" day counter";
        }

    /* avoid deprecation warnings */
    DayCounter Actual365NoLeap() {
        return QuantLib::Actual365Fixed(QuantLib::Actual365Fixed::NoLeap);
    }


using QuantLib::Compounding;
using QuantLib::Simple;
using QuantLib::Compounded;
using QuantLib::Continuous;
using QuantLib::SimpleThenCompounded;
using QuantLib::CompoundedThenSimple;


using QuantLib::InterestRate;

SWIGINTERN std::string InterestRate___str__(InterestRate *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }
SWIGINTERN std::vector< InterestRate > *new_std_vector_Sl_InterestRate_Sg___SWIG_2(int capacity){
        std::vector< InterestRate >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< InterestRate >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN InterestRate std_vector_Sl_InterestRate_Sg__getitemcopy(std::vector< InterestRate > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN InterestRate const &std_vector_Sl_InterestRate_Sg__getitem(std::vector< InterestRate > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__setitem(std::vector< InterestRate > *self,int index,InterestRate const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__AddRange(std::vector< InterestRate > *self,std::vector< InterestRate > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< InterestRate > *std_vector_Sl_InterestRate_Sg__GetRange(std::vector< InterestRate > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< InterestRate >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__Insert(std::vector< InterestRate > *self,int index,InterestRate const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__InsertRange(std::vector< InterestRate > *self,int index,std::vector< InterestRate > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__RemoveAt(std::vector< InterestRate > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__RemoveRange(std::vector< InterestRate > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< InterestRate > *std_vector_Sl_InterestRate_Sg__Repeat(InterestRate const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< InterestRate >(count, value);
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__Reverse__SWIG_0(std::vector< InterestRate > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__Reverse__SWIG_1(std::vector< InterestRate > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__SetRange(std::vector< InterestRate > *self,int index,std::vector< InterestRate > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }

using QuantLib::Rounding;
using QuantLib::UpRounding;
using QuantLib::DownRounding;
using QuantLib::ClosestRounding;
using QuantLib::CeilingTruncation;
using QuantLib::FloorTruncation;


using QuantLib::Currency;
using QuantLib::Money;

SWIGINTERN std::string Currency___str__(Currency *self){
            return self->name();
        }

using QuantLib::Extrapolator;


// safe versions which copy their arguments
template <class I>
class SafeInterpolation {
  public:
    SafeInterpolation(const Array& x, const Array& y)
    : x_(x), y_(y), f_(x_.begin(),x_.end(),y_.begin()) {}
    Real operator()(Real x, bool allowExtrapolation=false) {
        return f_(x, allowExtrapolation);
    }
    Array x_, y_;
    I f_;
};


typedef SafeInterpolation<QuantLib::LinearInterpolation> SafeLinearInterpolation;


typedef SafeInterpolation<QuantLib::LogLinearInterpolation> SafeLogLinearInterpolation;


typedef SafeInterpolation<QuantLib::BackwardFlatInterpolation> SafeBackwardFlatInterpolation;


typedef SafeInterpolation<QuantLib::ForwardFlatInterpolation> SafeForwardFlatInterpolation;


typedef SafeInterpolation<QuantLib::CubicNaturalSpline> SafeCubicNaturalSpline;

SWIGINTERN Real SafeCubicNaturalSpline_derivative__SWIG_0(SafeCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeCubicNaturalSpline_secondDerivative__SWIG_0(SafeCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeCubicNaturalSpline_primitive__SWIG_0(SafeCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::LogCubicNaturalSpline> SafeLogCubicNaturalSpline;

SWIGINTERN Real SafeLogCubicNaturalSpline_derivative__SWIG_0(SafeLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeLogCubicNaturalSpline_secondDerivative__SWIG_0(SafeLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeLogCubicNaturalSpline_primitive__SWIG_0(SafeLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::MonotonicCubicNaturalSpline> SafeMonotonicCubicNaturalSpline;

SWIGINTERN Real SafeMonotonicCubicNaturalSpline_derivative__SWIG_0(SafeMonotonicCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicCubicNaturalSpline_secondDerivative__SWIG_0(SafeMonotonicCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicCubicNaturalSpline_primitive__SWIG_0(SafeMonotonicCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::MonotonicLogCubicNaturalSpline> SafeMonotonicLogCubicNaturalSpline;

SWIGINTERN Real SafeMonotonicLogCubicNaturalSpline_derivative__SWIG_0(SafeMonotonicLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(SafeMonotonicLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicLogCubicNaturalSpline_primitive__SWIG_0(SafeMonotonicLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::KrugerCubic> SafeKrugerCubic;

SWIGINTERN Real SafeKrugerCubic_derivative__SWIG_0(SafeKrugerCubic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeKrugerCubic_secondDerivative__SWIG_0(SafeKrugerCubic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeKrugerCubic_primitive__SWIG_0(SafeKrugerCubic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::KrugerLogCubic> SafeKrugerLogCubic;

SWIGINTERN Real SafeKrugerLogCubic_derivative__SWIG_0(SafeKrugerLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeKrugerLogCubic_secondDerivative__SWIG_0(SafeKrugerLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeKrugerLogCubic_primitive__SWIG_0(SafeKrugerLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::FritschButlandCubic> SafeFritschButlandCubic;

SWIGINTERN Real SafeFritschButlandCubic_derivative__SWIG_0(SafeFritschButlandCubic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeFritschButlandCubic_secondDerivative__SWIG_0(SafeFritschButlandCubic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeFritschButlandCubic_primitive__SWIG_0(SafeFritschButlandCubic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::FritschButlandLogCubic> SafeFritschButlandLogCubic;

SWIGINTERN Real SafeFritschButlandLogCubic_derivative__SWIG_0(SafeFritschButlandLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeFritschButlandLogCubic_secondDerivative__SWIG_0(SafeFritschButlandLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeFritschButlandLogCubic_primitive__SWIG_0(SafeFritschButlandLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::Parabolic> SafeParabolic;

SWIGINTERN Real SafeParabolic_derivative__SWIG_0(SafeParabolic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeParabolic_secondDerivative__SWIG_0(SafeParabolic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeParabolic_primitive__SWIG_0(SafeParabolic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::LogParabolic> SafeLogParabolic;

SWIGINTERN Real SafeLogParabolic_derivative__SWIG_0(SafeLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeLogParabolic_secondDerivative__SWIG_0(SafeLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeLogParabolic_primitive__SWIG_0(SafeLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::MonotonicParabolic> SafeMonotonicParabolic;

SWIGINTERN Real SafeMonotonicParabolic_derivative__SWIG_0(SafeMonotonicParabolic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicParabolic_secondDerivative__SWIG_0(SafeMonotonicParabolic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicParabolic_primitive__SWIG_0(SafeMonotonicParabolic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::MonotonicLogParabolic> SafeMonotonicLogParabolic;

SWIGINTERN Real SafeMonotonicLogParabolic_derivative__SWIG_0(SafeMonotonicLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicLogParabolic_secondDerivative__SWIG_0(SafeMonotonicLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicLogParabolic_primitive__SWIG_0(SafeMonotonicLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

// safe versions which copy their arguments
template <class I>
class SafeInterpolation2D {
  public:
    SafeInterpolation2D(const Array& x, const Array& y, const Matrix& m)
    : x_(x), y_(y), m_(m), f_(x_.begin(),x_.end(),y_.begin(),y_.end(),m_) {}
    Real operator()(Real x, Real y, bool allowExtrapolation=false) {
        return f_(x,y, allowExtrapolation);
    }
  protected:
    Array x_, y_;
    Matrix m_;
    I f_;
};


typedef SafeInterpolation2D<QuantLib::BilinearInterpolation> SafeBilinearInterpolation;


typedef SafeInterpolation2D<QuantLib::BicubicSpline> SafeBicubicSpline;


using QuantLib::BackwardFlat;
using QuantLib::ForwardFlat;
using QuantLib::Linear;
using QuantLib::LogLinear;
using QuantLib::Cubic;

class MonotonicCubic : public Cubic {
  public:
    MonotonicCubic()
    : Cubic(QuantLib::CubicInterpolation::Spline, true,
            QuantLib::CubicInterpolation::SecondDerivative, 0.0,
            QuantLib::CubicInterpolation::SecondDerivative, 0.0) {}
};

class DefaultLogCubic : public QuantLib::LogCubic {
  public:
    DefaultLogCubic()
    : QuantLib::LogCubic(QuantLib::CubicInterpolation::Kruger) {}
};

class MonotonicLogCubic : public QuantLib::LogCubic {
  public:
    MonotonicLogCubic()
    : QuantLib::LogCubic(QuantLib::CubicInterpolation::Spline, true,
                         QuantLib::CubicInterpolation::SecondDerivative, 0.0,
                         QuantLib::CubicInterpolation::SecondDerivative, 0.0) {}
};


using QuantLib::YieldTermStructure;

SWIGINTERN bool boost_shared_ptr_Sl_YieldTermStructure_Sg__isNull(boost::shared_ptr< YieldTermStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_YieldTermStructure_Sg__asObservable(boost::shared_ptr< YieldTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_YieldTermStructure_Sg__asObservable(Handle< YieldTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }

using QuantLib::ImpliedTermStructure;
typedef boost::shared_ptr<YieldTermStructure> ImpliedTermStructurePtr;

SWIGINTERN ImpliedTermStructurePtr *new_ImpliedTermStructurePtr(Handle< YieldTermStructure > const &curveHandle,Date const &referenceDate){
            return new ImpliedTermStructurePtr(
                new ImpliedTermStructure(curveHandle, referenceDate));
        }

using QuantLib::ZeroSpreadedTermStructure;
using QuantLib::ForwardSpreadedTermStructure;
typedef boost::shared_ptr<YieldTermStructure> ZeroSpreadedTermStructurePtr;
typedef boost::shared_ptr<YieldTermStructure> ForwardSpreadedTermStructurePtr;

SWIGINTERN ZeroSpreadedTermStructurePtr *new_ZeroSpreadedTermStructurePtr__SWIG_0(Handle< YieldTermStructure > const &curveHandle,Handle< Quote > const &spreadHandle,Compounding comp=QuantLib::Continuous,Frequency freq=QuantLib::NoFrequency,DayCounter const &dc=DayCounter()){
            return new ZeroSpreadedTermStructurePtr(
                new ZeroSpreadedTermStructure(curveHandle,spreadHandle, comp, freq, dc));
        }
SWIGINTERN ForwardSpreadedTermStructurePtr *new_ForwardSpreadedTermStructurePtr(Handle< YieldTermStructure > const &curveHandle,Handle< Quote > const &spreadHandle){
            return new ForwardSpreadedTermStructurePtr(
                new ForwardSpreadedTermStructure(curveHandle,spreadHandle));
        }

using QuantLib::InterpolatedPiecewiseZeroSpreadedTermStructure;


typedef boost::shared_ptr<YieldTermStructure> SpreadedLinearZeroInterpolatedTermStructurePtr;

SWIGINTERN SpreadedLinearZeroInterpolatedTermStructurePtr *new_SpreadedLinearZeroInterpolatedTermStructurePtr__SWIG_0(Handle< YieldTermStructure > const &curveHandle,std::vector< Handle< Quote > > const &spreadHandles,std::vector< Date > const &dates,Compounding comp=QuantLib::Continuous,Frequency freq=QuantLib::NoFrequency,DayCounter const &dc=DayCounter(),Linear const &factory=Linear()){
            return new SpreadedLinearZeroInterpolatedTermStructurePtr(
                new InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>(
                          curveHandle,spreadHandles,dates,comp,freq,dc,factory));
        }

using QuantLib::FlatForward;
typedef boost::shared_ptr<YieldTermStructure> FlatForwardPtr;

SWIGINTERN FlatForwardPtr *new_FlatForwardPtr__SWIG_0(Date const &referenceDate,Handle< Quote > const &forward,DayCounter const &dayCounter,Compounding compounding=QuantLib::Continuous,Frequency frequency=QuantLib::Annual){
            return new FlatForwardPtr(
                           new FlatForward(referenceDate,forward,dayCounter,
                                           compounding,frequency));
        }
SWIGINTERN FlatForwardPtr *new_FlatForwardPtr__SWIG_3(Date const &referenceDate,Rate forward,DayCounter const &dayCounter,Compounding compounding=QuantLib::Continuous,Frequency frequency=QuantLib::Annual){
            return new FlatForwardPtr(
                           new FlatForward(referenceDate,forward,dayCounter,
                                           compounding,frequency));
        }
SWIGINTERN FlatForwardPtr *new_FlatForwardPtr__SWIG_6(Integer settlementDays,Calendar const &calendar,Handle< Quote > const &forward,DayCounter const &dayCounter,Compounding compounding=QuantLib::Continuous,Frequency frequency=QuantLib::Annual){
            return new FlatForwardPtr(
                 new FlatForward(settlementDays,calendar,forward,dayCounter,
                                 compounding,frequency));
        }
SWIGINTERN FlatForwardPtr *new_FlatForwardPtr__SWIG_9(Integer settlementDays,Calendar const &calendar,Rate forward,DayCounter const &dayCounter,Compounding compounding=QuantLib::Continuous,Frequency frequency=QuantLib::Annual){
            return new FlatForwardPtr(
                 new FlatForward(settlementDays,calendar,forward,dayCounter,
                                 compounding,frequency));
        }

using QuantLib::TimeSeries;
using QuantLib::IntervalPrice;

SWIGINTERN TimeSeries< Real > *new_TimeSeries_Sl_Real_Sg___SWIG_1(std::vector< Date > const &d,std::vector< double > const &v){
            return new TimeSeries<double>(d.begin(), d.end(), v.begin());
        }
SWIGINTERN TimeSeries< IntervalPrice > *new_TimeSeries_Sl_IntervalPrice_Sg___SWIG_1(std::vector< Date > const &d,std::vector< IntervalPrice > const &v){
            return new TimeSeries<IntervalPrice>(d.begin(), d.end(), v.begin());
        }
SWIGINTERN std::vector< IntervalPrice > *new_std_vector_Sl_IntervalPrice_Sg___SWIG_2(int capacity){
        std::vector< IntervalPrice >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< IntervalPrice >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN IntervalPrice std_vector_Sl_IntervalPrice_Sg__getitemcopy(std::vector< IntervalPrice > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN IntervalPrice const &std_vector_Sl_IntervalPrice_Sg__getitem(std::vector< IntervalPrice > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__setitem(std::vector< IntervalPrice > *self,int index,IntervalPrice const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__AddRange(std::vector< IntervalPrice > *self,std::vector< IntervalPrice > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< IntervalPrice > *std_vector_Sl_IntervalPrice_Sg__GetRange(std::vector< IntervalPrice > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< IntervalPrice >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__Insert(std::vector< IntervalPrice > *self,int index,IntervalPrice const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__InsertRange(std::vector< IntervalPrice > *self,int index,std::vector< IntervalPrice > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__RemoveAt(std::vector< IntervalPrice > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__RemoveRange(std::vector< IntervalPrice > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< IntervalPrice > *std_vector_Sl_IntervalPrice_Sg__Repeat(IntervalPrice const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< IntervalPrice >(count, value);
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__Reverse__SWIG_0(std::vector< IntervalPrice > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__Reverse__SWIG_1(std::vector< IntervalPrice > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__SetRange(std::vector< IntervalPrice > *self,int index,std::vector< IntervalPrice > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }

using QuantLib::IndexManager;


using QuantLib::Index;

SWIGINTERN bool boost_shared_ptr_Sl_Index_Sg__isNull(boost::shared_ptr< Index > *self){
                return !(*self);
            }
SWIGINTERN void boost_shared_ptr_Sl_Index_Sg__addFixings(boost::shared_ptr< Index > *self,std::vector< Date > const &fixingDates,std::vector< Rate > const &fixings){
        (*self)->addFixings(fixingDates.begin(),fixingDates.end(),
                            fixings.begin());
    }
SWIGINTERN std::string boost_shared_ptr_Sl_Index_Sg____str__(boost::shared_ptr< Index > *self){
        if (*self)
            return (*self)->name()+" index";
        else
            return "Null index";
    }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_Index_Sg__asObservable(boost::shared_ptr< Index > *self){
        return boost::shared_ptr<Observable>(*self);
    }

using QuantLib::InterestRateIndex;
typedef boost::shared_ptr<Index> InterestRateIndexPtr;

SWIGINTERN std::string InterestRateIndexPtr_familyName(InterestRateIndexPtr *self){
            return boost::dynamic_pointer_cast<InterestRateIndex>(*self)
                ->familyName();
        }
SWIGINTERN Period InterestRateIndexPtr_tenor(InterestRateIndexPtr *self){
            return boost::dynamic_pointer_cast<InterestRateIndex>(*self)
                ->tenor();
        }
SWIGINTERN Natural InterestRateIndexPtr_fixingDays(InterestRateIndexPtr *self){
            return boost::dynamic_pointer_cast<InterestRateIndex>(*self)
                ->fixingDays();
        }
SWIGINTERN Date InterestRateIndexPtr_fixingDate(InterestRateIndexPtr *self,Date const &valueDate){
            return boost::dynamic_pointer_cast<InterestRateIndex>(*self)
                ->fixingDate(valueDate);
        }
SWIGINTERN Currency InterestRateIndexPtr_currency(InterestRateIndexPtr *self){
            return boost::dynamic_pointer_cast<InterestRateIndex>(*self)
                ->currency();
        }
SWIGINTERN DayCounter InterestRateIndexPtr_dayCounter(InterestRateIndexPtr *self){
            return boost::dynamic_pointer_cast<InterestRateIndex>(*self)
                ->dayCounter();
        }
SWIGINTERN Date InterestRateIndexPtr_maturityDate(InterestRateIndexPtr *self,Date const &valueDate){
            return boost::dynamic_pointer_cast<InterestRateIndex>(*self)
                ->maturityDate(valueDate);
        }
SWIGINTERN Date InterestRateIndexPtr_valueDate(InterestRateIndexPtr *self,Date const &fixingDate){
            return boost::dynamic_pointer_cast<InterestRateIndex>(*self)
                ->valueDate(fixingDate);
        }

using QuantLib::IborIndex;
using QuantLib::OvernightIndex;
typedef boost::shared_ptr<Index> IborIndexPtr;
typedef boost::shared_ptr<Index> OvernightIndexPtr;

SWIGINTERN IborIndexPtr *new_IborIndexPtr__SWIG_0(std::string const &familyName,Period const &tenor,Integer settlementDays,Currency const &currency,Calendar const &calendar,BusinessDayConvention convention,bool endOfMonth,DayCounter const &dayCounter,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
            return new IborIndexPtr(new IborIndex(familyName, tenor,
                                                  settlementDays,
                                                  currency, calendar,
                                                  convention,
                                                  endOfMonth,
                                                  dayCounter, h));
        }
SWIGINTERN BusinessDayConvention IborIndexPtr_businessDayConvention(IborIndexPtr *self){
            return boost::dynamic_pointer_cast<IborIndex>(*self)
                ->businessDayConvention();
        }
SWIGINTERN bool IborIndexPtr_endOfMonth(IborIndexPtr *self){
            return boost::dynamic_pointer_cast<IborIndex>(*self)->endOfMonth();
        }
SWIGINTERN Handle< YieldTermStructure > IborIndexPtr_forwardingTermStructure(IborIndexPtr *self){
            return boost::dynamic_pointer_cast<IborIndex>(*self)
                ->forwardingTermStructure();
        }
SWIGINTERN IborIndexPtr IborIndexPtr_clone(IborIndexPtr *self,Handle< YieldTermStructure > const &h){
            return boost::dynamic_pointer_cast<IborIndex>(*self)
                ->clone(h);
    }

    IborIndexPtr as_iborindex(const InterestRateIndexPtr& index) {
        return boost::dynamic_pointer_cast<IborIndex>(index);
    }

SWIGINTERN OvernightIndexPtr *new_OvernightIndexPtr__SWIG_0(std::string const &familyName,Integer settlementDays,Currency const &currency,Calendar const &calendar,DayCounter const &dayCounter,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
            return new OvernightIndexPtr(
                new OvernightIndex(familyName, settlementDays,
                                   currency, calendar,
                                   dayCounter, h));
        }

using QuantLib::Libor;
typedef boost::shared_ptr<Index> LiborPtr;

SWIGINTERN LiborPtr *new_LiborPtr__SWIG_0(std::string const &familyName,Period const &tenor,Natural settlementDays,Currency const &currency,Calendar const &financialCenterCalendar,DayCounter const &dayCounter,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
            return new LiborPtr(
                new Libor(familyName,
                          tenor,
                          settlementDays,
                          currency,
                          financialCenterCalendar,
                          dayCounter,
                          h));
        }

using QuantLib::SwapIndex;
typedef boost::shared_ptr<Index> SwapIndexPtr;

SWIGINTERN SwapIndexPtr *new_SwapIndexPtr__SWIG_0(std::string const &familyName,Period const &tenor,Integer settlementDays,Currency const &currency,Calendar const &calendar,Period const &fixedLegTenor,BusinessDayConvention fixedLegConvention,DayCounter const &fixedLegDayCounter,IborIndexPtr const &iborIndex){
            boost::shared_ptr<IborIndex> xibor =
                boost::dynamic_pointer_cast<IborIndex>(iborIndex);
            return new SwapIndexPtr(new SwapIndex(familyName,
                                                  tenor, settlementDays,
                                                  currency, calendar,
                                                  fixedLegTenor,
                                                  fixedLegConvention,
                                                  fixedLegDayCounter,
                                                  xibor));
        }
SWIGINTERN SwapIndexPtr *new_SwapIndexPtr__SWIG_1(std::string const &familyName,Period const &tenor,Integer settlementDays,Currency const &currency,Calendar const &calendar,Period const &fixedLegTenor,BusinessDayConvention fixedLegConvention,DayCounter const &fixedLegDayCounter,IborIndexPtr const &iborIndex,Handle< YieldTermStructure > const &discountCurve){
            boost::shared_ptr<IborIndex> xibor =
                boost::dynamic_pointer_cast<IborIndex>(iborIndex);
            return new SwapIndexPtr(new SwapIndex(familyName,
                                                  tenor, settlementDays,
                                                  currency, calendar,
                                                  fixedLegTenor,
                                                  fixedLegConvention,
                                                  fixedLegDayCounter,
                                                  xibor, discountCurve));
        }
SWIGINTERN Period SwapIndexPtr_fixedLegTenor(SwapIndexPtr *self){
            return boost::dynamic_pointer_cast<SwapIndex>(*self)
                ->fixedLegTenor();
        }
SWIGINTERN BusinessDayConvention SwapIndexPtr_fixedLegConvention(SwapIndexPtr *self){
            return boost::dynamic_pointer_cast<SwapIndex>(*self)
                 ->fixedLegConvention();
        }
SWIGINTERN IborIndexPtr SwapIndexPtr_iborIndex(SwapIndexPtr *self){
            return boost::dynamic_pointer_cast<SwapIndex>(*self)
                ->iborIndex();
        }
SWIGINTERN Handle< YieldTermStructure > SwapIndexPtr_forwardingTermStructure(SwapIndexPtr *self){
            return boost::dynamic_pointer_cast<SwapIndex>(*self)
                ->forwardingTermStructure();
        }

using QuantLib::AUDLibor;
typedef boost::shared_ptr<Index> AUDLiborPtr;

SWIGINTERN AUDLiborPtr *new_AUDLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new AUDLiborPtr(new AUDLibor(tenor,h));
      }

using QuantLib::CADLibor;
typedef boost::shared_ptr<Index> CADLiborPtr;

SWIGINTERN CADLiborPtr *new_CADLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new CADLiborPtr(new CADLibor(tenor,h));
      }

using QuantLib::Cdor;
typedef boost::shared_ptr<Index> CdorPtr;

SWIGINTERN CdorPtr *new_CdorPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new CdorPtr(new Cdor(tenor,h));
      }

using QuantLib::CHFLibor;
typedef boost::shared_ptr<Index> CHFLiborPtr;

SWIGINTERN CHFLiborPtr *new_CHFLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new CHFLiborPtr(new CHFLibor(tenor,h));
      }

using QuantLib::DKKLibor;
typedef boost::shared_ptr<Index> DKKLiborPtr;

SWIGINTERN DKKLiborPtr *new_DKKLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new DKKLiborPtr(new DKKLibor(tenor,h));
      }

using QuantLib::Bbsw;
typedef boost::shared_ptr<Index> BbswPtr;

SWIGINTERN BbswPtr *new_BbswPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new BbswPtr(new Bbsw(tenor,h));
      }

using QuantLib::Bbsw1M;
typedef boost::shared_ptr<Index> Bbsw1MPtr;

SWIGINTERN Bbsw1MPtr *new_Bbsw1MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bbsw1MPtr(new Bbsw1M(h));
      }

using QuantLib::Bbsw2M;
typedef boost::shared_ptr<Index> Bbsw2MPtr;

SWIGINTERN Bbsw2MPtr *new_Bbsw2MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bbsw2MPtr(new Bbsw2M(h));
      }

using QuantLib::Bbsw3M;
typedef boost::shared_ptr<Index> Bbsw3MPtr;

SWIGINTERN Bbsw3MPtr *new_Bbsw3MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bbsw3MPtr(new Bbsw3M(h));
      }

using QuantLib::Bbsw4M;
typedef boost::shared_ptr<Index> Bbsw4MPtr;

SWIGINTERN Bbsw4MPtr *new_Bbsw4MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bbsw4MPtr(new Bbsw4M(h));
      }

using QuantLib::Bbsw5M;
typedef boost::shared_ptr<Index> Bbsw5MPtr;

SWIGINTERN Bbsw5MPtr *new_Bbsw5MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bbsw5MPtr(new Bbsw5M(h));
      }

using QuantLib::Bbsw6M;
typedef boost::shared_ptr<Index> Bbsw6MPtr;

SWIGINTERN Bbsw6MPtr *new_Bbsw6MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bbsw6MPtr(new Bbsw6M(h));
      }

using QuantLib::Bkbm;
typedef boost::shared_ptr<Index> BkbmPtr;

SWIGINTERN BkbmPtr *new_BkbmPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new BkbmPtr(new Bkbm(tenor,h));
      }

using QuantLib::Bkbm1M;
typedef boost::shared_ptr<Index> Bkbm1MPtr;

SWIGINTERN Bkbm1MPtr *new_Bkbm1MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bkbm1MPtr(new Bkbm1M(h));
      }

using QuantLib::Bkbm2M;
typedef boost::shared_ptr<Index> Bkbm2MPtr;

SWIGINTERN Bkbm2MPtr *new_Bkbm2MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bkbm2MPtr(new Bkbm2M(h));
      }

using QuantLib::Bkbm3M;
typedef boost::shared_ptr<Index> Bkbm3MPtr;

SWIGINTERN Bkbm3MPtr *new_Bkbm3MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bkbm3MPtr(new Bkbm3M(h));
      }

using QuantLib::Bkbm4M;
typedef boost::shared_ptr<Index> Bkbm4MPtr;

SWIGINTERN Bkbm4MPtr *new_Bkbm4MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bkbm4MPtr(new Bkbm4M(h));
      }

using QuantLib::Bkbm5M;
typedef boost::shared_ptr<Index> Bkbm5MPtr;

SWIGINTERN Bkbm5MPtr *new_Bkbm5MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bkbm5MPtr(new Bkbm5M(h));
      }

using QuantLib::Bkbm6M;
typedef boost::shared_ptr<Index> Bkbm6MPtr;

SWIGINTERN Bkbm6MPtr *new_Bkbm6MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Bkbm6MPtr(new Bkbm6M(h));
      }

using QuantLib::Euribor;
typedef boost::shared_ptr<Index> EuriborPtr;

SWIGINTERN EuriborPtr *new_EuriborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EuriborPtr(new Euribor(tenor,h));
      }

using QuantLib::EuriborSW;
typedef boost::shared_ptr<Index> EuriborSWPtr;

SWIGINTERN EuriborSWPtr *new_EuriborSWPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EuriborSWPtr(new EuriborSW(h));
      }

using QuantLib::Euribor2W;
typedef boost::shared_ptr<Index> Euribor2WPtr;

SWIGINTERN Euribor2WPtr *new_Euribor2WPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor2WPtr(new Euribor2W(h));
      }

using QuantLib::Euribor3W;
typedef boost::shared_ptr<Index> Euribor3WPtr;

SWIGINTERN Euribor3WPtr *new_Euribor3WPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor3WPtr(new Euribor3W(h));
      }

using QuantLib::Euribor1M;
typedef boost::shared_ptr<Index> Euribor1MPtr;

SWIGINTERN Euribor1MPtr *new_Euribor1MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor1MPtr(new Euribor1M(h));
      }

using QuantLib::Euribor2M;
typedef boost::shared_ptr<Index> Euribor2MPtr;

SWIGINTERN Euribor2MPtr *new_Euribor2MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor2MPtr(new Euribor2M(h));
      }

using QuantLib::Euribor3M;
typedef boost::shared_ptr<Index> Euribor3MPtr;

SWIGINTERN Euribor3MPtr *new_Euribor3MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor3MPtr(new Euribor3M(h));
      }

using QuantLib::Euribor4M;
typedef boost::shared_ptr<Index> Euribor4MPtr;

SWIGINTERN Euribor4MPtr *new_Euribor4MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor4MPtr(new Euribor4M(h));
      }

using QuantLib::Euribor5M;
typedef boost::shared_ptr<Index> Euribor5MPtr;

SWIGINTERN Euribor5MPtr *new_Euribor5MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor5MPtr(new Euribor5M(h));
      }

using QuantLib::Euribor6M;
typedef boost::shared_ptr<Index> Euribor6MPtr;

SWIGINTERN Euribor6MPtr *new_Euribor6MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor6MPtr(new Euribor6M(h));
      }

using QuantLib::Euribor7M;
typedef boost::shared_ptr<Index> Euribor7MPtr;

SWIGINTERN Euribor7MPtr *new_Euribor7MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor7MPtr(new Euribor7M(h));
      }

using QuantLib::Euribor8M;
typedef boost::shared_ptr<Index> Euribor8MPtr;

SWIGINTERN Euribor8MPtr *new_Euribor8MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor8MPtr(new Euribor8M(h));
      }

using QuantLib::Euribor9M;
typedef boost::shared_ptr<Index> Euribor9MPtr;

SWIGINTERN Euribor9MPtr *new_Euribor9MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor9MPtr(new Euribor9M(h));
      }

using QuantLib::Euribor10M;
typedef boost::shared_ptr<Index> Euribor10MPtr;

SWIGINTERN Euribor10MPtr *new_Euribor10MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor10MPtr(new Euribor10M(h));
      }

using QuantLib::Euribor11M;
typedef boost::shared_ptr<Index> Euribor11MPtr;

SWIGINTERN Euribor11MPtr *new_Euribor11MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor11MPtr(new Euribor11M(h));
      }

using QuantLib::Euribor1Y;
typedef boost::shared_ptr<Index> Euribor1YPtr;

SWIGINTERN Euribor1YPtr *new_Euribor1YPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor1YPtr(new Euribor1Y(h));
      }

using QuantLib::Euribor365;
typedef boost::shared_ptr<Index> Euribor365Ptr;

SWIGINTERN Euribor365Ptr *new_Euribor365Ptr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365Ptr(new Euribor365(tenor,h));
      }

using QuantLib::Euribor365_SW;
typedef boost::shared_ptr<Index> Euribor365_SWPtr;

SWIGINTERN Euribor365_SWPtr *new_Euribor365_SWPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_SWPtr(new Euribor365_SW(h));
      }

using QuantLib::Euribor365_2W;
typedef boost::shared_ptr<Index> Euribor365_2WPtr;

SWIGINTERN Euribor365_2WPtr *new_Euribor365_2WPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_2WPtr(new Euribor365_2W(h));
      }

using QuantLib::Euribor365_3W;
typedef boost::shared_ptr<Index> Euribor365_3WPtr;

SWIGINTERN Euribor365_3WPtr *new_Euribor365_3WPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_3WPtr(new Euribor365_3W(h));
      }

using QuantLib::Euribor365_1M;
typedef boost::shared_ptr<Index> Euribor365_1MPtr;

SWIGINTERN Euribor365_1MPtr *new_Euribor365_1MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_1MPtr(new Euribor365_1M(h));
      }

using QuantLib::Euribor365_2M;
typedef boost::shared_ptr<Index> Euribor365_2MPtr;

SWIGINTERN Euribor365_2MPtr *new_Euribor365_2MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_2MPtr(new Euribor365_2M(h));
      }

using QuantLib::Euribor365_3M;
typedef boost::shared_ptr<Index> Euribor365_3MPtr;

SWIGINTERN Euribor365_3MPtr *new_Euribor365_3MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_3MPtr(new Euribor365_3M(h));
      }

using QuantLib::Euribor365_4M;
typedef boost::shared_ptr<Index> Euribor365_4MPtr;

SWIGINTERN Euribor365_4MPtr *new_Euribor365_4MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_4MPtr(new Euribor365_4M(h));
      }

using QuantLib::Euribor365_5M;
typedef boost::shared_ptr<Index> Euribor365_5MPtr;

SWIGINTERN Euribor365_5MPtr *new_Euribor365_5MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_5MPtr(new Euribor365_5M(h));
      }

using QuantLib::Euribor365_6M;
typedef boost::shared_ptr<Index> Euribor365_6MPtr;

SWIGINTERN Euribor365_6MPtr *new_Euribor365_6MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_6MPtr(new Euribor365_6M(h));
      }

using QuantLib::Euribor365_7M;
typedef boost::shared_ptr<Index> Euribor365_7MPtr;

SWIGINTERN Euribor365_7MPtr *new_Euribor365_7MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_7MPtr(new Euribor365_7M(h));
      }

using QuantLib::Euribor365_8M;
typedef boost::shared_ptr<Index> Euribor365_8MPtr;

SWIGINTERN Euribor365_8MPtr *new_Euribor365_8MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_8MPtr(new Euribor365_8M(h));
      }

using QuantLib::Euribor365_9M;
typedef boost::shared_ptr<Index> Euribor365_9MPtr;

SWIGINTERN Euribor365_9MPtr *new_Euribor365_9MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_9MPtr(new Euribor365_9M(h));
      }

using QuantLib::Euribor365_10M;
typedef boost::shared_ptr<Index> Euribor365_10MPtr;

SWIGINTERN Euribor365_10MPtr *new_Euribor365_10MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_10MPtr(new Euribor365_10M(h));
      }

using QuantLib::Euribor365_11M;
typedef boost::shared_ptr<Index> Euribor365_11MPtr;

SWIGINTERN Euribor365_11MPtr *new_Euribor365_11MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_11MPtr(new Euribor365_11M(h));
      }

using QuantLib::Euribor365_1Y;
typedef boost::shared_ptr<Index> Euribor365_1YPtr;

SWIGINTERN Euribor365_1YPtr *new_Euribor365_1YPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new Euribor365_1YPtr(new Euribor365_1Y(h));
      }

using QuantLib::EURLibor;
typedef boost::shared_ptr<Index> EURLiborPtr;

SWIGINTERN EURLiborPtr *new_EURLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLiborPtr(new EURLibor(tenor,h));
      }

using QuantLib::EURLiborSW;
typedef boost::shared_ptr<Index> EURLiborSWPtr;

SWIGINTERN EURLiborSWPtr *new_EURLiborSWPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLiborSWPtr(new EURLiborSW(h));
      }

using QuantLib::EURLibor2W;
typedef boost::shared_ptr<Index> EURLibor2WPtr;

SWIGINTERN EURLibor2WPtr *new_EURLibor2WPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor2WPtr(new EURLibor2W(h));
      }

using QuantLib::EURLibor1M;
typedef boost::shared_ptr<Index> EURLibor1MPtr;

SWIGINTERN EURLibor1MPtr *new_EURLibor1MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor1MPtr(new EURLibor1M(h));
      }

using QuantLib::EURLibor2M;
typedef boost::shared_ptr<Index> EURLibor2MPtr;

SWIGINTERN EURLibor2MPtr *new_EURLibor2MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor2MPtr(new EURLibor2M(h));
      }

using QuantLib::EURLibor3M;
typedef boost::shared_ptr<Index> EURLibor3MPtr;

SWIGINTERN EURLibor3MPtr *new_EURLibor3MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor3MPtr(new EURLibor3M(h));
      }

using QuantLib::EURLibor4M;
typedef boost::shared_ptr<Index> EURLibor4MPtr;

SWIGINTERN EURLibor4MPtr *new_EURLibor4MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor4MPtr(new EURLibor4M(h));
      }

using QuantLib::EURLibor5M;
typedef boost::shared_ptr<Index> EURLibor5MPtr;

SWIGINTERN EURLibor5MPtr *new_EURLibor5MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor5MPtr(new EURLibor5M(h));
      }

using QuantLib::EURLibor6M;
typedef boost::shared_ptr<Index> EURLibor6MPtr;

SWIGINTERN EURLibor6MPtr *new_EURLibor6MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor6MPtr(new EURLibor6M(h));
      }

using QuantLib::EURLibor7M;
typedef boost::shared_ptr<Index> EURLibor7MPtr;

SWIGINTERN EURLibor7MPtr *new_EURLibor7MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor7MPtr(new EURLibor7M(h));
      }

using QuantLib::EURLibor8M;
typedef boost::shared_ptr<Index> EURLibor8MPtr;

SWIGINTERN EURLibor8MPtr *new_EURLibor8MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor8MPtr(new EURLibor8M(h));
      }

using QuantLib::EURLibor9M;
typedef boost::shared_ptr<Index> EURLibor9MPtr;

SWIGINTERN EURLibor9MPtr *new_EURLibor9MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor9MPtr(new EURLibor9M(h));
      }

using QuantLib::EURLibor10M;
typedef boost::shared_ptr<Index> EURLibor10MPtr;

SWIGINTERN EURLibor10MPtr *new_EURLibor10MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor10MPtr(new EURLibor10M(h));
      }

using QuantLib::EURLibor11M;
typedef boost::shared_ptr<Index> EURLibor11MPtr;

SWIGINTERN EURLibor11MPtr *new_EURLibor11MPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor11MPtr(new EURLibor11M(h));
      }

using QuantLib::EURLibor1Y;
typedef boost::shared_ptr<Index> EURLibor1YPtr;

SWIGINTERN EURLibor1YPtr *new_EURLibor1YPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EURLibor1YPtr(new EURLibor1Y(h));
      }

using QuantLib::GBPLibor;
typedef boost::shared_ptr<Index> GBPLiborPtr;

SWIGINTERN GBPLiborPtr *new_GBPLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new GBPLiborPtr(new GBPLibor(tenor,h));
      }

using QuantLib::Jibar;
typedef boost::shared_ptr<Index> JibarPtr;

SWIGINTERN JibarPtr *new_JibarPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new JibarPtr(new Jibar(tenor,h));
      }

using QuantLib::JPYLibor;
typedef boost::shared_ptr<Index> JPYLiborPtr;

SWIGINTERN JPYLiborPtr *new_JPYLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new JPYLiborPtr(new JPYLibor(tenor,h));
      }

using QuantLib::NZDLibor;
typedef boost::shared_ptr<Index> NZDLiborPtr;

SWIGINTERN NZDLiborPtr *new_NZDLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new NZDLiborPtr(new NZDLibor(tenor,h));
      }

using QuantLib::SEKLibor;
typedef boost::shared_ptr<Index> SEKLiborPtr;

SWIGINTERN SEKLiborPtr *new_SEKLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new SEKLiborPtr(new SEKLibor(tenor,h));
      }

using QuantLib::Tibor;
typedef boost::shared_ptr<Index> TiborPtr;

SWIGINTERN TiborPtr *new_TiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new TiborPtr(new Tibor(tenor,h));
      }

using QuantLib::TRLibor;
typedef boost::shared_ptr<Index> TRLiborPtr;

SWIGINTERN TRLiborPtr *new_TRLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new TRLiborPtr(new TRLibor(tenor,h));
      }

using QuantLib::USDLibor;
typedef boost::shared_ptr<Index> USDLiborPtr;

SWIGINTERN USDLiborPtr *new_USDLiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new USDLiborPtr(new USDLibor(tenor,h));
      }

using QuantLib::Zibor;
typedef boost::shared_ptr<Index> ZiborPtr;

SWIGINTERN ZiborPtr *new_ZiborPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new ZiborPtr(new Zibor(tenor,h));
      }

using QuantLib::Aonia;
typedef boost::shared_ptr<Index> AoniaPtr;

SWIGINTERN AoniaPtr *new_AoniaPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new AoniaPtr(new Aonia(h));
      }

using QuantLib::Eonia;
typedef boost::shared_ptr<Index> EoniaPtr;

SWIGINTERN EoniaPtr *new_EoniaPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EoniaPtr(new Eonia(h));
      }

using QuantLib::Sonia;
typedef boost::shared_ptr<Index> SoniaPtr;

SWIGINTERN SoniaPtr *new_SoniaPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new SoniaPtr(new Sonia(h));
      }

using QuantLib::FedFunds;
typedef boost::shared_ptr<Index> FedFundsPtr;

SWIGINTERN FedFundsPtr *new_FedFundsPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new FedFundsPtr(new FedFunds(h));
      }

using QuantLib::Nzocr;
typedef boost::shared_ptr<Index> NzocrPtr;

SWIGINTERN NzocrPtr *new_NzocrPtr__SWIG_0(Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new NzocrPtr(new Nzocr(h));
      }

using QuantLib::EuriborSwapIsdaFixA;
typedef boost::shared_ptr<Index> EuriborSwapIsdaFixAPtr;

SWIGINTERN EuriborSwapIsdaFixAPtr *new_EuriborSwapIsdaFixAPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EuriborSwapIsdaFixAPtr(new EuriborSwapIsdaFixA(tenor,h));
      }
SWIGINTERN EuriborSwapIsdaFixAPtr *new_EuriborSwapIsdaFixAPtr__SWIG_2(Period const &tenor,Handle< YieldTermStructure > const &h1,Handle< YieldTermStructure > const &h2){
          return new EuriborSwapIsdaFixAPtr(new EuriborSwapIsdaFixA(tenor,h1,h2));
      }

using QuantLib::EuriborSwapIsdaFixB;
typedef boost::shared_ptr<Index> EuriborSwapIsdaFixBPtr;

SWIGINTERN EuriborSwapIsdaFixBPtr *new_EuriborSwapIsdaFixBPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EuriborSwapIsdaFixBPtr(new EuriborSwapIsdaFixB(tenor,h));
      }
SWIGINTERN EuriborSwapIsdaFixBPtr *new_EuriborSwapIsdaFixBPtr__SWIG_2(Period const &tenor,Handle< YieldTermStructure > const &h1,Handle< YieldTermStructure > const &h2){
          return new EuriborSwapIsdaFixBPtr(new EuriborSwapIsdaFixB(tenor,h1,h2));
      }

using QuantLib::EuriborSwapIfrFix;
typedef boost::shared_ptr<Index> EuriborSwapIfrFixPtr;

SWIGINTERN EuriborSwapIfrFixPtr *new_EuriborSwapIfrFixPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EuriborSwapIfrFixPtr(new EuriborSwapIfrFix(tenor,h));
      }
SWIGINTERN EuriborSwapIfrFixPtr *new_EuriborSwapIfrFixPtr__SWIG_2(Period const &tenor,Handle< YieldTermStructure > const &h1,Handle< YieldTermStructure > const &h2){
          return new EuriborSwapIfrFixPtr(new EuriborSwapIfrFix(tenor,h1,h2));
      }

using QuantLib::EurLiborSwapIsdaFixA;
typedef boost::shared_ptr<Index> EurLiborSwapIsdaFixAPtr;

SWIGINTERN EurLiborSwapIsdaFixAPtr *new_EurLiborSwapIsdaFixAPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EurLiborSwapIsdaFixAPtr(new EurLiborSwapIsdaFixA(tenor,h));
      }
SWIGINTERN EurLiborSwapIsdaFixAPtr *new_EurLiborSwapIsdaFixAPtr__SWIG_2(Period const &tenor,Handle< YieldTermStructure > const &h1,Handle< YieldTermStructure > const &h2){
          return new EurLiborSwapIsdaFixAPtr(new EurLiborSwapIsdaFixA(tenor,h1,h2));
      }

using QuantLib::EurLiborSwapIsdaFixB;
typedef boost::shared_ptr<Index> EurLiborSwapIsdaFixBPtr;

SWIGINTERN EurLiborSwapIsdaFixBPtr *new_EurLiborSwapIsdaFixBPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EurLiborSwapIsdaFixBPtr(new EurLiborSwapIsdaFixB(tenor,h));
      }
SWIGINTERN EurLiborSwapIsdaFixBPtr *new_EurLiborSwapIsdaFixBPtr__SWIG_2(Period const &tenor,Handle< YieldTermStructure > const &h1,Handle< YieldTermStructure > const &h2){
          return new EurLiborSwapIsdaFixBPtr(new EurLiborSwapIsdaFixB(tenor,h1,h2));
      }

using QuantLib::EurLiborSwapIfrFix;
typedef boost::shared_ptr<Index> EurLiborSwapIfrFixPtr;

SWIGINTERN EurLiborSwapIfrFixPtr *new_EurLiborSwapIfrFixPtr__SWIG_0(Period const &tenor,Handle< YieldTermStructure > const &h=Handle< YieldTermStructure >()){
          return new EurLiborSwapIfrFixPtr(new EurLiborSwapIfrFix(tenor,h));
      }
SWIGINTERN EurLiborSwapIfrFixPtr *new_EurLiborSwapIfrFixPtr__SWIG_2(Period const &tenor,Handle< YieldTermStructure > const &h1,Handle< YieldTermStructure > const &h2){
          return new EurLiborSwapIfrFixPtr(new EurLiborSwapIfrFix(tenor,h1,h2));
      }

using QuantLib::Bisection;
using QuantLib::Brent;
using QuantLib::FalsePosition;
using QuantLib::Newton;
using QuantLib::NewtonSafe;
using QuantLib::Ridder;
using QuantLib::Secant;

SWIGINTERN Real Brent_solve__SWIG_0(Brent *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Brent_solve__SWIG_1(Brent *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real Bisection_solve__SWIG_0(Bisection *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Bisection_solve__SWIG_1(Bisection *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real FalsePosition_solve__SWIG_0(FalsePosition *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real FalsePosition_solve__SWIG_1(FalsePosition *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real Ridder_solve__SWIG_0(Ridder *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Ridder_solve__SWIG_1(Ridder *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real Secant_solve__SWIG_0(Secant *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Secant_solve__SWIG_1(Secant *self,UnaryFunctionDelegate *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }

using QuantLib::Constraint;
using QuantLib::BoundaryConstraint;
using QuantLib::NoConstraint;
using QuantLib::PositiveConstraint;
using QuantLib::CompositeConstraint;
using QuantLib::NonhomogeneousBoundaryConstraint;


using QuantLib::EndCriteria;


using QuantLib::OptimizationMethod;
using QuantLib::ConjugateGradient;
using QuantLib::Simplex;
using QuantLib::SteepestDescent;
using QuantLib::BFGS;
using QuantLib::LevenbergMarquardt;
using QuantLib::DifferentialEvolution;
using QuantLib::SamplerGaussian;
using QuantLib::SamplerLogNormal;
using QuantLib::SamplerMirrorGaussian;
using QuantLib::ProbabilityBoltzmannDownhill;
using QuantLib::TemperatureExponential;
using QuantLib::ReannealingTrivial;
using QuantLib::GaussianSimulatedAnnealing;
using QuantLib::MirrorGaussianSimulatedAnnealing;
using QuantLib::LogNormalSimulatedAnnealing;



using QuantLib::Problem;


    class Optimizer {};

SWIGINTERN Array Optimizer_solve(Optimizer *self,CostFunctionDelegate *function,Constraint &c,OptimizationMethod &m,EndCriteria &e,Array &iv){
        DotNetCostFunction f(function);
        Problem p(f,c,iv);
        m.minimize(p, e);
        return p.currentValue();
    }

using QuantLib::VolatilityType;
using QuantLib::ShiftedLognormal;
using QuantLib::Normal;


using QuantLib::BlackVolTermStructure;
using QuantLib::LocalVolTermStructure;
using QuantLib::OptionletVolatilityStructure;
using QuantLib::SwaptionVolatilityStructure;

SWIGINTERN bool boost_shared_ptr_Sl_BlackVolTermStructure_Sg__isNull(boost::shared_ptr< BlackVolTermStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_BlackVolTermStructure_Sg__asObservable(boost::shared_ptr< BlackVolTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_BlackVolTermStructure_Sg__asObservable(Handle< BlackVolTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN bool boost_shared_ptr_Sl_LocalVolTermStructure_Sg__isNull(boost::shared_ptr< LocalVolTermStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_LocalVolTermStructure_Sg__asObservable(boost::shared_ptr< LocalVolTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_LocalVolTermStructure_Sg__asObservable(Handle< LocalVolTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN bool boost_shared_ptr_Sl_OptionletVolatilityStructure_Sg__isNull(boost::shared_ptr< OptionletVolatilityStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_OptionletVolatilityStructure_Sg__asObservable(boost::shared_ptr< OptionletVolatilityStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_OptionletVolatilityStructure_Sg__asObservable(Handle< OptionletVolatilityStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }

using QuantLib::SwaptionVolatilityStructure;

SWIGINTERN bool boost_shared_ptr_Sl_SwaptionVolatilityStructure_Sg__isNull(boost::shared_ptr< SwaptionVolatilityStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_SwaptionVolatilityStructure_Sg__asObservable(boost::shared_ptr< SwaptionVolatilityStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_SwaptionVolatilityStructure_Sg__asObservable(Handle< SwaptionVolatilityStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }

using QuantLib::BlackConstantVol;
typedef boost::shared_ptr<BlackVolTermStructure> BlackConstantVolPtr;

SWIGINTERN BlackConstantVolPtr *new_BlackConstantVolPtr__SWIG_0(Date const &referenceDate,Calendar const &c,Volatility volatility,DayCounter const &dayCounter){
            return new BlackConstantVolPtr(
                new BlackConstantVol(referenceDate, c,
                                     volatility, dayCounter));
        }
SWIGINTERN BlackConstantVolPtr *new_BlackConstantVolPtr__SWIG_1(Date const &referenceDate,Calendar const &c,Handle< Quote > const &volatility,DayCounter const &dayCounter){
            return new BlackConstantVolPtr(
                new BlackConstantVol(referenceDate, c,
                                     volatility, dayCounter));
        }
SWIGINTERN BlackConstantVolPtr *new_BlackConstantVolPtr__SWIG_2(Natural settlementDays,Calendar const &calendar,Volatility volatility,DayCounter const &dayCounter){
            return new BlackConstantVolPtr(
                new BlackConstantVol(settlementDays, calendar,
                                     volatility, dayCounter));
        }
SWIGINTERN BlackConstantVolPtr *new_BlackConstantVolPtr__SWIG_3(Natural settlementDays,Calendar const &calendar,Handle< Quote > const &volatility,DayCounter const &dayCounter){
            return new BlackConstantVolPtr(
                new BlackConstantVol(settlementDays, calendar,
                                     volatility, dayCounter));
        }

using QuantLib::BlackVarianceCurve;
typedef boost::shared_ptr<BlackVolTermStructure> BlackVarianceCurvePtr;

SWIGINTERN BlackVarianceCurvePtr *new_BlackVarianceCurvePtr__SWIG_0(Date const &referenceDate,std::vector< Date > const &dates,std::vector< Real > const &volatilities,DayCounter const &dayCounter,bool forceMonotoneVariance=true){
            return new BlackVarianceCurvePtr(
                new BlackVarianceCurve(referenceDate,
                                       dates, volatilities,
                                       dayCounter, forceMonotoneVariance));
        }

using QuantLib::BlackVarianceSurface;
typedef boost::shared_ptr<BlackVolTermStructure> BlackVarianceSurfacePtr;

SWIGINTERN BlackVarianceSurfacePtr *new_BlackVarianceSurfacePtr__SWIG_0(Date const &referenceDate,Calendar const &cal,std::vector< Date > const &dates,std::vector< Real > const &strikes,Matrix const &blackVols,DayCounter const &dayCounter,BlackVarianceSurface::Extrapolation lower=BlackVarianceSurface::InterpolatorDefaultExtrapolation,BlackVarianceSurface::Extrapolation upper=BlackVarianceSurface::InterpolatorDefaultExtrapolation,std::string const &interpolator=""){
            BlackVarianceSurface* surf =
                new BlackVarianceSurface(referenceDate,cal,
                                         dates,strikes,
                                         blackVols,dayCounter,lower,upper);
            std::string s = boost::algorithm::to_lower_copy(interpolator);
            if (s == "" || s == "bilinear") {
                surf->setInterpolation<QuantLib::Bilinear>();
            } else if (s == "bicubic") {
                surf->setInterpolation<QuantLib::Bicubic>();
            } else {
                QL_FAIL("Unknown interpolator: " << interpolator);
            }
            return new BlackVarianceSurfacePtr(surf);
        }
SWIGINTERN void BlackVarianceSurfacePtr_setInterpolation__SWIG_0(BlackVarianceSurfacePtr *self,std::string const &interpolator=""){
            std::string s = boost::algorithm::to_lower_copy(interpolator);
            boost::shared_ptr<BlackVarianceSurface> surf =
                boost::dynamic_pointer_cast<BlackVarianceSurface>(*self);
            if (s == "" || s == "bilinear") {
                surf->setInterpolation<QuantLib::Bilinear>();
            } else if (s == "bicubic") {
                surf->setInterpolation<QuantLib::Bicubic>();
            } else {
                QL_FAIL("Unknown interpolator: " << interpolator);
            }
            
        }

using QuantLib::LocalConstantVol;
typedef boost::shared_ptr<LocalVolTermStructure> LocalConstantVolPtr;

SWIGINTERN LocalConstantVolPtr *new_LocalConstantVolPtr__SWIG_0(Date const &referenceDate,Volatility volatility,DayCounter const &dayCounter){
            return new LocalConstantVolPtr(
                new LocalConstantVol(referenceDate, volatility, dayCounter));
        }
SWIGINTERN LocalConstantVolPtr *new_LocalConstantVolPtr__SWIG_1(Date const &referenceDate,Handle< Quote > const &volatility,DayCounter const &dayCounter){
            return new LocalConstantVolPtr(
                new LocalConstantVol(referenceDate, volatility, dayCounter));
        }
SWIGINTERN LocalConstantVolPtr *new_LocalConstantVolPtr__SWIG_2(Integer settlementDays,Calendar const &calendar,Volatility volatility,DayCounter const &dayCounter){
            return new LocalConstantVolPtr(
                new LocalConstantVol(settlementDays, calendar,
                                     volatility, dayCounter));
        }
SWIGINTERN LocalConstantVolPtr *new_LocalConstantVolPtr__SWIG_3(Integer settlementDays,Calendar const &calendar,Handle< Quote > const &volatility,DayCounter const &dayCounter){
            return new LocalConstantVolPtr(
                new LocalConstantVol(settlementDays, calendar,
                                     volatility, dayCounter));
        }

using QuantLib::LocalVolSurface;
typedef boost::shared_ptr<LocalVolTermStructure> LocalVolSurfacePtr;

SWIGINTERN LocalVolSurfacePtr *new_LocalVolSurfacePtr__SWIG_0(Handle< BlackVolTermStructure > const &blackTS,Handle< YieldTermStructure > const &riskFreeTS,Handle< YieldTermStructure > const &dividendTS,Handle< Quote > const &underlying){
            return new LocalVolSurfacePtr(
                new LocalVolSurface(blackTS, riskFreeTS, 
                    dividendTS, underlying));
        
        }
SWIGINTERN LocalVolSurfacePtr *new_LocalVolSurfacePtr__SWIG_1(Handle< BlackVolTermStructure > const &blackTS,Handle< YieldTermStructure > const &riskFreeTS,Handle< YieldTermStructure > const &dividendTS,Real underlying){
            return new LocalVolSurfacePtr(
                new LocalVolSurface(blackTS, riskFreeTS, 
                    dividendTS, underlying));
        }

using QuantLib::ConstantOptionletVolatility;
typedef boost::shared_ptr<OptionletVolatilityStructure>
    ConstantOptionletVolatilityPtr;

SWIGINTERN ConstantOptionletVolatilityPtr *new_ConstantOptionletVolatilityPtr__SWIG_0(Date const &referenceDate,Calendar const &cal,BusinessDayConvention bdc,Volatility volatility,DayCounter const &dayCounter,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            return new ConstantOptionletVolatilityPtr(
                new ConstantOptionletVolatility(referenceDate,
                                                cal, bdc, volatility,
                                                dayCounter, type, shift));
        }
SWIGINTERN ConstantOptionletVolatilityPtr *new_ConstantOptionletVolatilityPtr__SWIG_3(Date const &referenceDate,Calendar const &cal,BusinessDayConvention bdc,Handle< Quote > const &volatility,DayCounter const &dayCounter,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            return new ConstantOptionletVolatilityPtr(
                new ConstantOptionletVolatility(referenceDate,
                                                cal, bdc, volatility,
                                                dayCounter, type, shift));
        }
SWIGINTERN ConstantOptionletVolatilityPtr *new_ConstantOptionletVolatilityPtr__SWIG_6(Natural settlementDays,Calendar const &cal,BusinessDayConvention bdc,Volatility volatility,DayCounter const &dayCounter,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            return new ConstantOptionletVolatilityPtr(
                new ConstantOptionletVolatility(settlementDays,
                                                cal, bdc, volatility,
                                                dayCounter, type, shift));
        }
SWIGINTERN ConstantOptionletVolatilityPtr *new_ConstantOptionletVolatilityPtr__SWIG_9(Natural settlementDays,Calendar const &cal,BusinessDayConvention bdc,Handle< Quote > const &volatility,DayCounter const &dayCounter,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            return new ConstantOptionletVolatilityPtr(
                new ConstantOptionletVolatility(settlementDays,
                                                cal, bdc, volatility,
                                                dayCounter, type, shift));
        }

using QuantLib::ConstantSwaptionVolatility;
typedef boost::shared_ptr<SwaptionVolatilityStructure>
    ConstantSwaptionVolatilityPtr;

SWIGINTERN ConstantSwaptionVolatilityPtr *new_ConstantSwaptionVolatilityPtr__SWIG_0(Natural settlementDays,Calendar const &cal,BusinessDayConvention bdc,Handle< Quote > const &volatility,DayCounter const &dc,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            return new ConstantSwaptionVolatilityPtr(
                new ConstantSwaptionVolatility(settlementDays, cal, bdc,
                                               volatility, dc, type, shift));
        }
SWIGINTERN ConstantSwaptionVolatilityPtr *new_ConstantSwaptionVolatilityPtr__SWIG_3(Date const &referenceDate,Calendar const &cal,BusinessDayConvention bdc,Handle< Quote > const &volatility,DayCounter const &dc,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            return new ConstantSwaptionVolatilityPtr(
                new ConstantSwaptionVolatility(referenceDate, cal, bdc,
                                               volatility, dc, type, shift));
        }
SWIGINTERN ConstantSwaptionVolatilityPtr *new_ConstantSwaptionVolatilityPtr__SWIG_6(Natural settlementDays,Calendar const &cal,BusinessDayConvention bdc,Volatility volatility,DayCounter const &dc,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            return new ConstantSwaptionVolatilityPtr(
                new ConstantSwaptionVolatility(settlementDays, cal, bdc,
                                               volatility, dc, type, shift));
        }
SWIGINTERN ConstantSwaptionVolatilityPtr *new_ConstantSwaptionVolatilityPtr__SWIG_9(Date const &referenceDate,Calendar const &cal,BusinessDayConvention bdc,Volatility volatility,DayCounter const &dc,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            return new ConstantSwaptionVolatilityPtr(
                new ConstantSwaptionVolatility(referenceDate, cal, bdc,
                                               volatility, dc, type, shift));
        }

using QuantLib::SwaptionVolatilityMatrix;
typedef boost::shared_ptr<SwaptionVolatilityStructure>
    SwaptionVolatilityMatrixPtr;

SWIGINTERN SwaptionVolatilityMatrixPtr *new_SwaptionVolatilityMatrixPtr__SWIG_0(Date const &referenceDate,std::vector< Date > const &dates,std::vector< Period > const &lengths,Matrix const &vols,DayCounter const &dayCounter,bool const flatExtrapolation=false,VolatilityType const type=ShiftedLognormal,Matrix const &shifts=Matrix()){
            return new SwaptionVolatilityMatrixPtr(
                new SwaptionVolatilityMatrix(referenceDate,dates,lengths,
                                             vols,dayCounter,
                                             flatExtrapolation, type, shifts));
        }
SWIGINTERN SwaptionVolatilityMatrixPtr *new_SwaptionVolatilityMatrixPtr__SWIG_4(Calendar const &calendar,BusinessDayConvention bdc,std::vector< Period > const &optionTenors,std::vector< Period > const &swapTenors,std::vector< std::vector< Handle< Quote > > > const &vols,DayCounter const &dayCounter,bool const flatExtrapolation=false,VolatilityType const type=ShiftedLognormal,std::vector< std::vector< Real > > const &shifts=std::vector< std::vector< Real > >()){
            return new SwaptionVolatilityMatrixPtr(
                new SwaptionVolatilityMatrix(calendar,bdc,optionTenors,
                                             swapTenors,vols,dayCounter,
                                             flatExtrapolation, type, shifts));
        }
SWIGINTERN SwaptionVolatilityMatrixPtr *new_SwaptionVolatilityMatrixPtr__SWIG_8(Calendar const &calendar,BusinessDayConvention bdc,std::vector< Period > const &optionTenors,std::vector< Period > const &swapTenors,Matrix const &vols,DayCounter const &dayCounter,bool const flatExtrapolation=false,VolatilityType const type=ShiftedLognormal,Matrix const &shifts=Matrix()){
            return new SwaptionVolatilityMatrixPtr(
                new SwaptionVolatilityMatrix(calendar,bdc,optionTenors,
                                             swapTenors,vols,dayCounter,
                                             flatExtrapolation, type, shifts));
        }

using QuantLib::SwaptionVolCube1;
using QuantLib::SwaptionVolCube2;
typedef boost::shared_ptr<SwaptionVolatilityStructure> SwaptionVolCube1Ptr;
typedef boost::shared_ptr<SwaptionVolatilityStructure> SwaptionVolCube2Ptr;

SWIGINTERN SwaptionVolCube1Ptr *new_SwaptionVolCube1Ptr__SWIG_0(Handle< SwaptionVolatilityStructure > const &atmVolStructure,std::vector< Period > const &optionTenors,std::vector< Period > const &swapTenors,std::vector< Spread > const &strikeSpreads,std::vector< std::vector< Handle< Quote > > > const &volSpreads,SwapIndexPtr const &swapIndexBase,SwapIndexPtr const &shortSwapIndexBase,bool vegaWeightedSmileFit,std::vector< std::vector< Handle< Quote > > > const &parametersGuess,std::vector< bool > const &isParameterFixed,bool isAtmCalibrated,boost::shared_ptr< EndCriteria > const &endCriteria=boost::shared_ptr< EndCriteria >(),Real maxErrorTolerance=Null< Real >(),boost::shared_ptr< OptimizationMethod > const &optMethod=boost::shared_ptr< OptimizationMethod >()){
            const boost::shared_ptr<SwapIndex> swi =
                boost::dynamic_pointer_cast<SwapIndex>(swapIndexBase);
            const boost::shared_ptr<SwapIndex> shortSwi =
                boost::dynamic_pointer_cast<SwapIndex>(shortSwapIndexBase);
            return new SwaptionVolCube1Ptr(
                new SwaptionVolCube1(
                    atmVolStructure,optionTenors,swapTenors, strikeSpreads,
                    volSpreads, swi, shortSwi, vegaWeightedSmileFit,
                    parametersGuess,isParameterFixed,isAtmCalibrated,
                    endCriteria,maxErrorTolerance,optMethod));
        }
SWIGINTERN Matrix SwaptionVolCube1Ptr_sparseSabrParameters(SwaptionVolCube1Ptr const *self){
            return boost::dynamic_pointer_cast<SwaptionVolCube1>(*self)
                ->sparseSabrParameters();
        }
SWIGINTERN Matrix SwaptionVolCube1Ptr_denseSabrParameters(SwaptionVolCube1Ptr const *self){
            return boost::dynamic_pointer_cast<SwaptionVolCube1>(*self)
                ->denseSabrParameters();
        }
SWIGINTERN Matrix SwaptionVolCube1Ptr_marketVolCube(SwaptionVolCube1Ptr const *self){
            return boost::dynamic_pointer_cast<SwaptionVolCube1>(*self)
                ->marketVolCube();
        }
SWIGINTERN Matrix SwaptionVolCube1Ptr_volCubeAtmCalibrated(SwaptionVolCube1Ptr const *self){
            return boost::dynamic_pointer_cast<SwaptionVolCube1>(*self)
                ->volCubeAtmCalibrated();
        }
SWIGINTERN SwaptionVolCube2Ptr *new_SwaptionVolCube2Ptr(Handle< SwaptionVolatilityStructure > const &atmVolStructure,std::vector< Period > const &optionTenors,std::vector< Period > const &swapTenors,std::vector< Spread > const &strikeSpreads,std::vector< std::vector< Handle< Quote > > > const &volSpreads,SwapIndexPtr const &swapIndexBase,SwapIndexPtr const &shortSwapIndexBase,bool vegaWeightedSmileFit){
            const boost::shared_ptr<SwapIndex> swi =
                boost::dynamic_pointer_cast<SwapIndex>(swapIndexBase);
            const boost::shared_ptr<SwapIndex> shortSwi =
                boost::dynamic_pointer_cast<SwapIndex>(shortSwapIndexBase);
            return new SwaptionVolCube2Ptr(
                new SwaptionVolCube2(
                    atmVolStructure,optionTenors,swapTenors,strikeSpreads,
                    volSpreads, swi, shortSwi, vegaWeightedSmileFit));
        }

using QuantLib::StochasticProcess;

SWIGINTERN bool boost_shared_ptr_Sl_StochasticProcess_Sg__isNull(boost::shared_ptr< StochasticProcess > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_StochasticProcess_Sg__asObservable(boost::shared_ptr< StochasticProcess > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN std::vector< boost::shared_ptr< StochasticProcess > > *new_std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<StochasticProcess> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<StochasticProcess> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< StochasticProcess > std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< StochasticProcess > const &std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__getitem(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__setitem(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index,boost::shared_ptr< StochasticProcess > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__AddRange(std::vector< boost::shared_ptr< StochasticProcess > > *self,std::vector< boost::shared_ptr< StochasticProcess > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< StochasticProcess > > *std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__GetRange(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<StochasticProcess> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Insert(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index,boost::shared_ptr< StochasticProcess > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index,std::vector< boost::shared_ptr< StochasticProcess > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< StochasticProcess > > *std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Repeat(boost::shared_ptr< StochasticProcess > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<StochasticProcess> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< StochasticProcess > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__SetRange(std::vector< boost::shared_ptr< StochasticProcess > > *self,int index,std::vector< boost::shared_ptr< StochasticProcess > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Contains(std::vector< boost::shared_ptr< StochasticProcess > > *self,boost::shared_ptr< StochasticProcess > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< StochasticProcess > > *self,boost::shared_ptr< StochasticProcess > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<StochasticProcess> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< StochasticProcess > > *self,boost::shared_ptr< StochasticProcess > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<StochasticProcess> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Remove(std::vector< boost::shared_ptr< StochasticProcess > > *self,boost::shared_ptr< StochasticProcess > const &value){
        std::vector< boost::shared_ptr<StochasticProcess> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

using QuantLib::StochasticProcess1D;
typedef boost::shared_ptr<StochasticProcess> StochasticProcess1DPtr;

SWIGINTERN Real StochasticProcess1DPtr_x0(StochasticProcess1DPtr *self){
          return boost::dynamic_pointer_cast<StochasticProcess1D>(*self)->x0();
      }
SWIGINTERN Real StochasticProcess1DPtr_drift(StochasticProcess1DPtr *self,Time t,Real x){
          return boost::dynamic_pointer_cast<StochasticProcess1D>(*self)
              ->drift(t, x);
      }
SWIGINTERN Real StochasticProcess1DPtr_diffusion(StochasticProcess1DPtr *self,Time t,Real x){
          return boost::dynamic_pointer_cast<StochasticProcess1D>(*self)
              ->diffusion(t, x);
      }
SWIGINTERN Real StochasticProcess1DPtr_expectation(StochasticProcess1DPtr *self,Time t0,Real x0,Time dt){
          return boost::dynamic_pointer_cast<StochasticProcess1D>(*self)
              ->expectation(t0, x0, dt);
      }
SWIGINTERN Real StochasticProcess1DPtr_stdDeviation(StochasticProcess1DPtr *self,Time t0,Real x0,Time dt){
          return boost::dynamic_pointer_cast<StochasticProcess1D>(*self)
              ->stdDeviation(t0, x0, dt);
      }
SWIGINTERN Real StochasticProcess1DPtr_variance(StochasticProcess1DPtr *self,Time t0,Real x0,Time dt){
          return boost::dynamic_pointer_cast<StochasticProcess1D>(*self)
              ->variance(t0, x0, dt);
      }
SWIGINTERN Real StochasticProcess1DPtr_evolve(StochasticProcess1DPtr *self,Time t0,Real x0,Time dt,Real dw){
          return boost::dynamic_pointer_cast<StochasticProcess1D>(*self)
              ->evolve(t0, x0, dt, dw);
      }
SWIGINTERN Real StochasticProcess1DPtr_apply(StochasticProcess1DPtr *self,Real x0,Real dx){
          return boost::dynamic_pointer_cast<StochasticProcess1D>(*self)
              ->apply(x0, dx);
      }

using QuantLib::GeneralizedBlackScholesProcess;
typedef boost::shared_ptr<StochasticProcess> GeneralizedBlackScholesProcessPtr;

SWIGINTERN GeneralizedBlackScholesProcessPtr *new_GeneralizedBlackScholesProcessPtr(Handle< Quote > const &s0,Handle< YieldTermStructure > const &dividendTS,Handle< YieldTermStructure > const &riskFreeTS,Handle< BlackVolTermStructure > const &volTS){
          return new GeneralizedBlackScholesProcessPtr(
                       new GeneralizedBlackScholesProcess(s0, dividendTS,
                                                          riskFreeTS, volTS));
      }
SWIGINTERN Handle< Quote > GeneralizedBlackScholesProcessPtr_stateVariable(GeneralizedBlackScholesProcessPtr *self){
          return boost::dynamic_pointer_cast<
                      GeneralizedBlackScholesProcess>(*self)->stateVariable();
      }
SWIGINTERN Handle< YieldTermStructure > GeneralizedBlackScholesProcessPtr_dividendYield(GeneralizedBlackScholesProcessPtr *self){
          return boost::dynamic_pointer_cast<
                      GeneralizedBlackScholesProcess>(*self)->dividendYield();
      }
SWIGINTERN Handle< YieldTermStructure > GeneralizedBlackScholesProcessPtr_riskFreeRate(GeneralizedBlackScholesProcessPtr *self){
          return boost::dynamic_pointer_cast<
                      GeneralizedBlackScholesProcess>(*self)->riskFreeRate();
      }
SWIGINTERN Handle< BlackVolTermStructure > GeneralizedBlackScholesProcessPtr_blackVolatility(GeneralizedBlackScholesProcessPtr const *self){
          return boost::dynamic_pointer_cast<
                      GeneralizedBlackScholesProcess>(*self)->blackVolatility();
      }

using QuantLib::BlackScholesProcess;
typedef boost::shared_ptr<StochasticProcess> BlackScholesProcessPtr;

SWIGINTERN BlackScholesProcessPtr *new_BlackScholesProcessPtr(Handle< Quote > const &s0,Handle< YieldTermStructure > const &riskFreeTS,Handle< BlackVolTermStructure > const &volTS){
          return new BlackScholesProcessPtr(
                            new BlackScholesProcess(s0, riskFreeTS, volTS));
      }

using QuantLib::BlackScholesMertonProcess;
typedef boost::shared_ptr<StochasticProcess> BlackScholesMertonProcessPtr;

SWIGINTERN BlackScholesMertonProcessPtr *new_BlackScholesMertonProcessPtr(Handle< Quote > const &s0,Handle< YieldTermStructure > const &dividendTS,Handle< YieldTermStructure > const &riskFreeTS,Handle< BlackVolTermStructure > const &volTS){
          return new BlackScholesMertonProcessPtr(
                            new BlackScholesMertonProcess(s0, dividendTS,
                                                          riskFreeTS, volTS));
      }

using QuantLib::BlackProcess;
typedef boost::shared_ptr<StochasticProcess> BlackProcessPtr;

SWIGINTERN BlackProcessPtr *new_BlackProcessPtr(Handle< Quote > const &s0,Handle< YieldTermStructure > const &riskFreeTS,Handle< BlackVolTermStructure > const &volTS){
          return new BlackProcessPtr(new BlackProcess(s0, riskFreeTS, volTS));
      }

using QuantLib::GarmanKohlagenProcess;
typedef boost::shared_ptr<StochasticProcess> GarmanKohlagenProcessPtr;

SWIGINTERN GarmanKohlagenProcessPtr *new_GarmanKohlagenProcessPtr(Handle< Quote > const &s0,Handle< YieldTermStructure > const &foreignRiskFreeTS,Handle< YieldTermStructure > const &domesticRiskFreeTS,Handle< BlackVolTermStructure > const &volTS){
          return new GarmanKohlagenProcessPtr(
                        new GarmanKohlagenProcess(s0, foreignRiskFreeTS,
                                                  domesticRiskFreeTS, volTS));
      }

using QuantLib::Merton76Process;
typedef boost::shared_ptr<StochasticProcess> Merton76ProcessPtr;

SWIGINTERN Merton76ProcessPtr *new_Merton76ProcessPtr(Handle< Quote > const &stateVariable,Handle< YieldTermStructure > const &dividendTS,Handle< YieldTermStructure > const &riskFreeTS,Handle< BlackVolTermStructure > const &volTS,Handle< Quote > const &jumpIntensity,Handle< Quote > const &meanLogJump,Handle< Quote > const &jumpVolatility){
            return new Merton76ProcessPtr(
                              new Merton76Process(stateVariable, dividendTS,
                                                  riskFreeTS, volTS,
                                                  jumpIntensity, meanLogJump,
                                                  jumpVolatility));
      }

using QuantLib::StochasticProcessArray;
typedef boost::shared_ptr<StochasticProcess> StochasticProcessArrayPtr;

SWIGINTERN StochasticProcessArrayPtr *new_StochasticProcessArrayPtr(std::vector< boost::shared_ptr< StochasticProcess > > const &array,Matrix const &correlation){
          std::vector<boost::shared_ptr<StochasticProcess1D> > in_array;
          for (Size j=0; j < array.size(); j++)
              in_array.push_back(
                  boost::dynamic_pointer_cast<StochasticProcess1D>(array[j]));
          return new StochasticProcessArrayPtr(
                           new StochasticProcessArray(in_array, correlation));
      }

using QuantLib::GeometricBrownianMotionProcess;
typedef boost::shared_ptr<StochasticProcess> GeometricBrownianMotionProcessPtr;

SWIGINTERN GeometricBrownianMotionProcessPtr *new_GeometricBrownianMotionProcessPtr(Real initialValue,Real mu,Real sigma){
          return new GeometricBrownianMotionProcessPtr(
                 new GeometricBrownianMotionProcess(initialValue, mu, sigma));
      }

using QuantLib::VarianceGammaProcess;
typedef boost::shared_ptr<StochasticProcess> VarianceGammaProcessPtr;

SWIGINTERN VarianceGammaProcessPtr *new_VarianceGammaProcessPtr(Handle< Quote > const &s0,Handle< YieldTermStructure > const &dividendYield,Handle< YieldTermStructure > const &riskFreeRate,Real sigma,Real nu,Real theta){
          return new VarianceGammaProcessPtr(
                 new VarianceGammaProcess(s0,dividendYield,riskFreeRate,sigma,nu,theta));
      }

using QuantLib::HestonProcess;
typedef boost::shared_ptr<StochasticProcess> HestonProcessPtr;

SWIGINTERN HestonProcessPtr *new_HestonProcessPtr(Handle< YieldTermStructure > const &riskFreeTS,Handle< YieldTermStructure > const &dividendTS,Handle< Quote > const &s0,Real v0,Real kappa,Real theta,Real sigma,Real rho){
		return new HestonProcessPtr(
			new HestonProcess(riskFreeTS, dividendTS, s0, v0, 
						      kappa, theta, sigma, rho));	
      }
SWIGINTERN Handle< Quote > HestonProcessPtr_s0(HestonProcessPtr *self){
          return boost::dynamic_pointer_cast<
                      HestonProcess>(*self)->s0();
      }
SWIGINTERN Handle< YieldTermStructure > HestonProcessPtr_dividendYield(HestonProcessPtr *self){
          return boost::dynamic_pointer_cast<
                      HestonProcess>(*self)->dividendYield();
      }
SWIGINTERN Handle< YieldTermStructure > HestonProcessPtr_riskFreeRate(HestonProcessPtr *self){
          return boost::dynamic_pointer_cast<
                      HestonProcess>(*self)->riskFreeRate();
      }

using QuantLib::BatesProcess;
typedef boost::shared_ptr<StochasticProcess> BatesProcessPtr;

SWIGINTERN BatesProcessPtr *new_BatesProcessPtr(Handle< YieldTermStructure > const &riskFreeRate,Handle< YieldTermStructure > const &dividendYield,Handle< Quote > const &s0,Real v0,Real kappa,Real theta,Real sigma,Real rho,Real lambda,Real nu,Real delta){
		return new BatesProcessPtr(
			new BatesProcess(riskFreeRate, dividendYield, s0, v0, 
							 kappa, theta, sigma, rho, 
							 lambda, nu, delta));
	  }

using QuantLib::HullWhiteProcess;
typedef boost::shared_ptr<StochasticProcess> HullWhiteProcessPtr;

SWIGINTERN HullWhiteProcessPtr *new_HullWhiteProcessPtr(Handle< YieldTermStructure > const &riskFreeTS,Real a,Real sigma){
            return new HullWhiteProcessPtr(new HullWhiteProcess(riskFreeTS, a, sigma));	
        }

using QuantLib::HullWhiteForwardProcess;
typedef boost::shared_ptr<StochasticProcess> HullWhiteForwardProcessPtr;

SWIGINTERN HullWhiteForwardProcessPtr *new_HullWhiteForwardProcessPtr(Handle< YieldTermStructure > const &riskFreeTS,Real a,Real sigma){
            return new HullWhiteForwardProcessPtr(
                new HullWhiteForwardProcess(riskFreeTS, a, sigma));
        }
SWIGINTERN Real HullWhiteForwardProcessPtr_alpha(HullWhiteForwardProcessPtr const *self,Time t){
            return boost::dynamic_pointer_cast<HullWhiteForwardProcess>(*self)      ->alpha(t);
        }
SWIGINTERN Real HullWhiteForwardProcessPtr_M_T(HullWhiteForwardProcessPtr const *self,Real s,Real t,Real T){
            return boost::dynamic_pointer_cast<HullWhiteForwardProcess>(*self)      ->M_T(s, t, T);
        }
SWIGINTERN Real HullWhiteForwardProcessPtr_B(HullWhiteForwardProcessPtr const *self,Time t,Time T){
            return boost::dynamic_pointer_cast<HullWhiteForwardProcess>(*self)      ->B(t, T);
        }
SWIGINTERN void HullWhiteForwardProcessPtr_setForwardMeasureTime(HullWhiteForwardProcessPtr *self,Time t){
            boost::dynamic_pointer_cast<HullWhiteForwardProcess>(*self)             ->setForwardMeasureTime(t);
        }

using QuantLib::GsrProcess;
typedef boost::shared_ptr<StochasticProcess> GsrProcessPtr;

SWIGINTERN GsrProcessPtr *new_GsrProcessPtr__SWIG_0(Array const &times,Array const &vols,Array const &reversions,Real const T=60.0){
            return new GsrProcessPtr(new GsrProcess(times, vols, reversions, T));
        }
SWIGINTERN Real GsrProcessPtr_sigma(GsrProcessPtr *self,Time t){
            return boost::dynamic_pointer_cast<GsrProcess>(*self)->sigma(t);
        }
SWIGINTERN Real GsrProcessPtr_reversion(GsrProcessPtr *self,Time t){
            return boost::dynamic_pointer_cast<GsrProcess>(*self)->reversion(t);
        }
SWIGINTERN Real GsrProcessPtr_y(GsrProcessPtr *self,Time t){
            return boost::dynamic_pointer_cast<GsrProcess>(*self)->y(t);
        }
SWIGINTERN Real GsrProcessPtr_G(GsrProcessPtr *self,Time t,Time T,Real x){
            return boost::dynamic_pointer_cast<GsrProcess>(*self)->G(t, T, x);
        }
SWIGINTERN void GsrProcessPtr_setForwardMeasureTime(GsrProcessPtr *self,Time t){
            boost::dynamic_pointer_cast<GsrProcess>(*self)->setForwardMeasureTime(t);
        }

    GsrProcessPtr as_gsr_process(
                           const boost::shared_ptr<StochasticProcess>& proc) {
        return boost::dynamic_pointer_cast<GsrProcess>(proc);
    }


using QuantLib::PricingEngine;

SWIGINTERN bool boost_shared_ptr_Sl_PricingEngine_Sg__isNull(boost::shared_ptr< PricingEngine > *self){
                return !(*self);
            }

using QuantLib::Instrument;

SWIGINTERN bool boost_shared_ptr_Sl_Instrument_Sg__isNull(boost::shared_ptr< Instrument > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_Instrument_Sg__asObservable(boost::shared_ptr< Instrument > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN std::vector< boost::shared_ptr< Instrument > > *new_std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<Instrument> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<Instrument> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< Instrument > std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< Instrument > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< Instrument > const &std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__getitem(std::vector< boost::shared_ptr< Instrument > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__setitem(std::vector< boost::shared_ptr< Instrument > > *self,int index,boost::shared_ptr< Instrument > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__AddRange(std::vector< boost::shared_ptr< Instrument > > *self,std::vector< boost::shared_ptr< Instrument > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< Instrument > > *std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__GetRange(std::vector< boost::shared_ptr< Instrument > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<Instrument> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Insert(std::vector< boost::shared_ptr< Instrument > > *self,int index,boost::shared_ptr< Instrument > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< Instrument > > *self,int index,std::vector< boost::shared_ptr< Instrument > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< Instrument > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< Instrument > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< Instrument > > *std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Repeat(boost::shared_ptr< Instrument > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<Instrument> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< Instrument > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< Instrument > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__SetRange(std::vector< boost::shared_ptr< Instrument > > *self,int index,std::vector< boost::shared_ptr< Instrument > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Contains(std::vector< boost::shared_ptr< Instrument > > *self,boost::shared_ptr< Instrument > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< Instrument > > *self,boost::shared_ptr< Instrument > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<Instrument> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< Instrument > > *self,boost::shared_ptr< Instrument > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<Instrument> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Remove(std::vector< boost::shared_ptr< Instrument > > *self,boost::shared_ptr< Instrument > const &value){
        std::vector< boost::shared_ptr<Instrument> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

using QuantLib::Stock;
typedef boost::shared_ptr<Instrument> StockPtr;

SWIGINTERN StockPtr *new_StockPtr(Handle< Quote > const &quote){
            return new StockPtr(new Stock(quote));
        }

using QuantLib::CompositeInstrument;
typedef boost::shared_ptr<Instrument> CompositeInstrumentPtr;

SWIGINTERN CompositeInstrumentPtr *new_CompositeInstrumentPtr(){
            return new CompositeInstrumentPtr(new CompositeInstrument);
        }
SWIGINTERN void CompositeInstrumentPtr_add__SWIG_0(CompositeInstrumentPtr *self,boost::shared_ptr< Instrument > const &instrument,Real multiplier=1.0){
            boost::dynamic_pointer_cast<CompositeInstrument>(*self)
                ->add(instrument, multiplier);
        }
SWIGINTERN void CompositeInstrumentPtr_subtract__SWIG_0(CompositeInstrumentPtr *self,boost::shared_ptr< Instrument > const &instrument,Real multiplier=1.0){
            boost::dynamic_pointer_cast<CompositeInstrument>(*self)
                ->subtract(instrument, multiplier);
        }

using QuantLib::Schedule;
using QuantLib::DateGeneration;


using QuantLib::CashFlow;

SWIGINTERN bool boost_shared_ptr_Sl_CashFlow_Sg__isNull(boost::shared_ptr< CashFlow > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_CashFlow_Sg__asObservable(boost::shared_ptr< CashFlow > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN std::vector< boost::shared_ptr< CashFlow > > *new_std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<CashFlow> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<CashFlow> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< CashFlow > std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< CashFlow > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< CashFlow > const &std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__getitem(std::vector< boost::shared_ptr< CashFlow > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__setitem(std::vector< boost::shared_ptr< CashFlow > > *self,int index,boost::shared_ptr< CashFlow > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__AddRange(std::vector< boost::shared_ptr< CashFlow > > *self,std::vector< boost::shared_ptr< CashFlow > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< CashFlow > > *std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__GetRange(std::vector< boost::shared_ptr< CashFlow > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<CashFlow> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Insert(std::vector< boost::shared_ptr< CashFlow > > *self,int index,boost::shared_ptr< CashFlow > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< CashFlow > > *self,int index,std::vector< boost::shared_ptr< CashFlow > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< CashFlow > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< CashFlow > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< CashFlow > > *std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Repeat(boost::shared_ptr< CashFlow > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<CashFlow> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< CashFlow > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< CashFlow > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__SetRange(std::vector< boost::shared_ptr< CashFlow > > *self,int index,std::vector< boost::shared_ptr< CashFlow > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Contains(std::vector< boost::shared_ptr< CashFlow > > *self,boost::shared_ptr< CashFlow > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< CashFlow > > *self,boost::shared_ptr< CashFlow > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<CashFlow> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< CashFlow > > *self,boost::shared_ptr< CashFlow > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<CashFlow> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Remove(std::vector< boost::shared_ptr< CashFlow > > *self,boost::shared_ptr< CashFlow > const &value){
        std::vector< boost::shared_ptr<CashFlow> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

using QuantLib::SimpleCashFlow;
using QuantLib::Redemption;
using QuantLib::AmortizingPayment;
using QuantLib::Coupon;
using QuantLib::FixedRateCoupon;
using QuantLib::IborCoupon;
using QuantLib::Leg;
using QuantLib::FloatingRateCoupon;

typedef boost::shared_ptr<CashFlow> SimpleCashFlowPtr;
typedef boost::shared_ptr<CashFlow> RedemptionPtr;
typedef boost::shared_ptr<CashFlow> AmortizingPaymentPtr;
typedef boost::shared_ptr<CashFlow> CouponPtr;
typedef boost::shared_ptr<CashFlow> IborCouponPtr;
typedef boost::shared_ptr<CashFlow> FixedRateCouponPtr;
typedef boost::shared_ptr<CashFlow> FloatingRateCouponPtr;

SWIGINTERN SimpleCashFlowPtr *new_SimpleCashFlowPtr(Real amount,Date const &date){
            return new SimpleCashFlowPtr(new SimpleCashFlow(amount,date));
        }
SWIGINTERN RedemptionPtr *new_RedemptionPtr(Real amount,Date const &date){
            return new RedemptionPtr(new Redemption(amount,date));
        }
SWIGINTERN AmortizingPaymentPtr *new_AmortizingPaymentPtr(Real amount,Date const &date){
            return new AmortizingPaymentPtr(new AmortizingPayment(amount,date));
        }
SWIGINTERN Real CouponPtr_nominal(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)->nominal();
        }
SWIGINTERN Date CouponPtr_accrualStartDate(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->accrualStartDate();
        }
SWIGINTERN Date CouponPtr_accrualEndDate(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->accrualEndDate();
        }
SWIGINTERN Date CouponPtr_referencePeriodStart(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->referencePeriodStart();
        }
SWIGINTERN Date CouponPtr_referencePeriodEnd(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->referencePeriodEnd();
        }
SWIGINTERN Date CouponPtr_exCouponDate(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->exCouponDate();
        }
SWIGINTERN Real CouponPtr_rate(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)->rate();
        }
SWIGINTERN Time CouponPtr_accrualPeriod(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->accrualPeriod();
        }
SWIGINTERN BigInteger CouponPtr_accrualDays(CouponPtr *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->accrualDays();
        }
SWIGINTERN DayCounter CouponPtr_dayCounter(CouponPtr const *self){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->dayCounter();
        }
SWIGINTERN Real CouponPtr_accruedAmount(CouponPtr *self,Date const &date){
            return boost::dynamic_pointer_cast<Coupon>(*self)
                ->accruedAmount(date);
        }

    CouponPtr as_coupon(const boost::shared_ptr<CashFlow>& cf) {
        return boost::dynamic_pointer_cast<Coupon>(cf);
    }

SWIGINTERN FixedRateCouponPtr *new_FixedRateCouponPtr__SWIG_0(Date const &paymentDate,Real nominal,Rate rate,DayCounter const &dayCounter,Date const &startDate,Date const &endDate,Date const &refPeriodStart=Date(),Date const &refPeriodEnd=Date(),Date const &exCouponDate=Date()){
            return new FixedRateCouponPtr(
                new FixedRateCoupon(paymentDate, nominal, rate,
                                    dayCounter, startDate, endDate,
                                    refPeriodStart, refPeriodEnd,
                                    exCouponDate));
        }
SWIGINTERN InterestRate FixedRateCouponPtr_interestRate(FixedRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FixedRateCoupon>(*self)
                ->interestRate();
        }

    FixedRateCouponPtr as_fixed_rate_coupon(
                                      const boost::shared_ptr<CashFlow>& cf) {
        return boost::dynamic_pointer_cast<FixedRateCoupon>(cf);
    }


using QuantLib::FloatingRateCouponPricer;

SWIGINTERN bool boost_shared_ptr_Sl_FloatingRateCouponPricer_Sg__isNull(boost::shared_ptr< FloatingRateCouponPricer > *self){
                return !(*self);
            }
SWIGINTERN Date FloatingRateCouponPtr_fixingDate(FloatingRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->fixingDate();
        }
SWIGINTERN Integer FloatingRateCouponPtr_fixingDays(FloatingRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->fixingDays();
        }
SWIGINTERN bool FloatingRateCouponPtr_isInArrears(FloatingRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->isInArrears();
        }
SWIGINTERN Real FloatingRateCouponPtr_gearing(FloatingRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->gearing();
        }
SWIGINTERN Rate FloatingRateCouponPtr_spread(FloatingRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->spread();
        }
SWIGINTERN Rate FloatingRateCouponPtr_indexFixing(FloatingRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->indexFixing();
        }
SWIGINTERN Rate FloatingRateCouponPtr_adjustedFixing(FloatingRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->adjustedFixing();
        }
SWIGINTERN Rate FloatingRateCouponPtr_convexityAdjustment(FloatingRateCouponPtr *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->convexityAdjustment();
        }
SWIGINTERN Real FloatingRateCouponPtr_price(FloatingRateCouponPtr *self,Handle< YieldTermStructure > const &discountCurve){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->price(discountCurve);
        }
SWIGINTERN InterestRateIndexPtr FloatingRateCouponPtr_index(FloatingRateCouponPtr const *self){
            return boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->index();
        }
SWIGINTERN void FloatingRateCouponPtr_setPricer(FloatingRateCouponPtr *self,boost::shared_ptr< FloatingRateCouponPricer > const &p){
            boost::dynamic_pointer_cast<FloatingRateCoupon>(*self)
                ->setPricer(p);
        }

    FloatingRateCouponPtr as_floating_rate_coupon(
                                      const boost::shared_ptr<CashFlow>& cf) {
        return boost::dynamic_pointer_cast<FloatingRateCoupon>(cf);
    }


using QuantLib::CappedFlooredCoupon;
typedef boost::shared_ptr<CashFlow> CappedFlooredCouponPtr;

SWIGINTERN CappedFlooredCouponPtr *new_CappedFlooredCouponPtr__SWIG_0(FloatingRateCouponPtr const &underlying,Rate cap=Null< Rate >(),Rate floor=Null< Rate >()){
            boost::shared_ptr<FloatingRateCoupon> u =
                boost::dynamic_pointer_cast<FloatingRateCoupon>(underlying);
            return new CappedFlooredCouponPtr(
                new CappedFlooredCoupon(u,cap,floor));
        }
SWIGINTERN Rate CappedFlooredCouponPtr_cap(CappedFlooredCouponPtr *self){
           return boost::dynamic_pointer_cast<CappedFlooredCoupon>(*self)
                ->cap();
        }
SWIGINTERN Rate CappedFlooredCouponPtr_floor(CappedFlooredCouponPtr *self){
           return boost::dynamic_pointer_cast<CappedFlooredCoupon>(*self)
                ->floor();
        }
SWIGINTERN Rate CappedFlooredCouponPtr_effectiveCap(CappedFlooredCouponPtr *self){
           return boost::dynamic_pointer_cast<CappedFlooredCoupon>(*self)
                ->effectiveCap();
        }
SWIGINTERN Rate CappedFlooredCouponPtr_effectiveFloor(CappedFlooredCouponPtr *self){
           return boost::dynamic_pointer_cast<CappedFlooredCoupon>(*self)
                ->effectiveFloor();
        }
SWIGINTERN bool CappedFlooredCouponPtr_isCapped(CappedFlooredCouponPtr *self){
           return boost::dynamic_pointer_cast<CappedFlooredCoupon>(*self)
                ->isCapped();
        }
SWIGINTERN bool CappedFlooredCouponPtr_isFloored(CappedFlooredCouponPtr *self){
           return boost::dynamic_pointer_cast<CappedFlooredCoupon>(*self)
                ->isFloored();
        }
SWIGINTERN void CappedFlooredCouponPtr_setPricer(CappedFlooredCouponPtr *self,boost::shared_ptr< FloatingRateCouponPricer > const &p){
            boost::dynamic_pointer_cast<CappedFlooredCoupon>(*self)
                ->setPricer(p);
        }
SWIGINTERN IborCouponPtr *new_IborCouponPtr__SWIG_0(Date const &paymentDate,Real nominal,Date const &startDate,Date const &endDate,Integer fixingDays,InterestRateIndexPtr &index,Real gearing=1.0,Spread spread=0.0,Date const &refPeriodStart=Date(),Date const &refPeriodEnd=Date(),DayCounter const &dayCounter=DayCounter()){
            const boost::shared_ptr<IborIndex> iri =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new IborCouponPtr(
                new IborCoupon(paymentDate, nominal, startDate, endDate,
                               fixingDays, iri, gearing, spread,
                               refPeriodStart, refPeriodEnd, dayCounter));
        }

using QuantLib::IborCouponPricer;
using QuantLib::BlackIborCouponPricer;
typedef boost::shared_ptr<FloatingRateCouponPricer> IborCouponPricerPtr;
typedef boost::shared_ptr<FloatingRateCouponPricer> BlackIborCouponPricerPtr;

SWIGINTERN Handle< OptionletVolatilityStructure > IborCouponPricerPtr_capletVolatility(IborCouponPricerPtr *self){
            return boost::dynamic_pointer_cast<IborCouponPricer>(*self)
                ->capletVolatility();
        }
SWIGINTERN void IborCouponPricerPtr_setCapletVolatility__SWIG_0(IborCouponPricerPtr *self,Handle< OptionletVolatilityStructure > const &v=Handle< OptionletVolatilityStructure >()){
            boost::dynamic_pointer_cast<IborCouponPricer>(*self)
                ->setCapletVolatility(v);
        }
SWIGINTERN BlackIborCouponPricerPtr *new_BlackIborCouponPricerPtr__SWIG_0(Handle< OptionletVolatilityStructure > const &v=Handle< OptionletVolatilityStructure >()){
            return new BlackIborCouponPricerPtr(new BlackIborCouponPricer(v));
        }

using QuantLib::CmsCoupon;
using QuantLib::CappedFlooredCmsCoupon;
typedef boost::shared_ptr<CashFlow> CmsCouponPtr;
typedef boost::shared_ptr<CashFlow> CappedFlooredCmsCouponPtr;

SWIGINTERN CmsCouponPtr *new_CmsCouponPtr__SWIG_0(Date const &paymentDate,Real nominal,Date const &startDate,Date const &endDate,Integer fixingDays,SwapIndexPtr const &index,Real gearing=1.0,Spread spread=0.0,Date const &refPeriodStart=Date(),Date const &refPeriodEnd=Date(),DayCounter const &dayCounter=DayCounter(),bool isInArrears=false){
            const boost::shared_ptr<SwapIndex> swi =
                boost::dynamic_pointer_cast<SwapIndex>(index);
            return new CmsCouponPtr(
                new CmsCoupon(paymentDate,nominal,startDate,endDate,
                              fixingDays,swi,gearing,spread,
                              refPeriodStart,refPeriodEnd,
                              dayCounter,isInArrears));
        }

using QuantLib::CmsCouponPricer;
using QuantLib::AnalyticHaganPricer;
using QuantLib::NumericHaganPricer;
using QuantLib::GFunctionFactory;
using QuantLib::LinearTsrPricer;
typedef boost::shared_ptr<FloatingRateCouponPricer> CmsCouponPricerPtr;
typedef boost::shared_ptr<FloatingRateCouponPricer> AnalyticHaganPricerPtr;
typedef boost::shared_ptr<FloatingRateCouponPricer> NumericHaganPricerPtr;
typedef boost::shared_ptr<FloatingRateCouponPricer> LinearTsrPricerPtr;

SWIGINTERN Handle< SwaptionVolatilityStructure > CmsCouponPricerPtr_swaptionVolatility(CmsCouponPricerPtr *self){
            return boost::dynamic_pointer_cast<CmsCouponPricer>(*self)
                ->swaptionVolatility();
        }
SWIGINTERN void CmsCouponPricerPtr_setSwaptionVolatility__SWIG_0(CmsCouponPricerPtr *self,Handle< SwaptionVolatilityStructure > const &v=Handle< SwaptionVolatilityStructure >()){
            boost::dynamic_pointer_cast<CmsCouponPricer>(*self)
                ->setSwaptionVolatility(v);
        }
SWIGINTERN AnalyticHaganPricerPtr *new_AnalyticHaganPricerPtr(Handle< SwaptionVolatilityStructure > const &v,GFunctionFactory::YieldCurveModel model,Handle< Quote > const &meanReversion){
            return new AnalyticHaganPricerPtr(
                            new AnalyticHaganPricer(v, model, meanReversion));
        }
SWIGINTERN NumericHaganPricerPtr *new_NumericHaganPricerPtr__SWIG_0(Handle< SwaptionVolatilityStructure > const &v,GFunctionFactory::YieldCurveModel model,Handle< Quote > const &meanReversion,Rate lowerLimit=0.0,Rate upperLimit=1.0,Real precision=1.0e-6){
             return new NumericHaganPricerPtr(
                 new NumericHaganPricer(v, model, meanReversion,
                                        lowerLimit, upperLimit, precision));
        }
SWIGINTERN CappedFlooredCmsCouponPtr *new_CappedFlooredCmsCouponPtr__SWIG_0(Date const &paymentDate,Real nominal,Date const &startDate,Date const &endDate,Natural fixingDays,SwapIndexPtr const &index,Real gearing=1.0,Spread spread=0.0,Rate const cap=Null< Rate >(),Rate const floor=Null< Rate >(),Date const &refPeriodStart=Date(),Date const &refPeriodEnd=Date(),DayCounter const &dayCounter=DayCounter(),bool isInArrears=false){
            const boost::shared_ptr<SwapIndex> swi =
                boost::dynamic_pointer_cast<SwapIndex>(index);
            return new CappedFlooredCmsCouponPtr(
                new CappedFlooredCmsCoupon(
                      paymentDate, nominal, startDate, endDate, fixingDays,
                      swi, gearing, spread, cap, floor, refPeriodStart,
                      refPeriodEnd, dayCounter, isInArrears));
        }
SWIGINTERN LinearTsrPricerPtr *new_LinearTsrPricerPtr__SWIG_0(Handle< SwaptionVolatilityStructure > const &swaptionVol,Handle< Quote > const &meanReversion,Handle< YieldTermStructure > const &couponDiscountCurve=Handle< YieldTermStructure >(),LinearTsrPricer::Settings const &settings=LinearTsrPricer::Settings()){
            return new LinearTsrPricerPtr(
                          new LinearTsrPricer(swaptionVol, meanReversion,
                                              couponDiscountCurve, settings));
        }

Leg _FixedRateLeg(const Schedule& schedule,
                  const DayCounter& dayCount,
                  const std::vector<Real>& nominals,
                  const std::vector<Rate>& couponRates,
                  BusinessDayConvention paymentAdjustment = Following,
                  const DayCounter& firstPeriodDayCount = DayCounter()) {
    return QuantLib::FixedRateLeg(schedule)
        .withNotionals(nominals)
        .withCouponRates(couponRates,dayCount)
        .withPaymentAdjustment(paymentAdjustment)
        .withFirstPeriodDayCounter(firstPeriodDayCount);
}


Leg _IborLeg(const std::vector<Real>& nominals,
             const Schedule& schedule,
             const boost::shared_ptr<Index>& index,
             const DayCounter& paymentDayCounter = DayCounter(),
             const BusinessDayConvention paymentConvention = Following,
             const std::vector<Natural>& fixingDays = std::vector<Natural>(),
             const std::vector<Real>& gearings = std::vector<Real>(),
             const std::vector<Spread>& spreads = std::vector<Spread>(),
             const std::vector<Rate>& caps = std::vector<Rate>(),
             const std::vector<Rate>& floors = std::vector<Rate>(),
             bool isInArrears = false) {
    boost::shared_ptr<IborIndex> libor =
        boost::dynamic_pointer_cast<IborIndex>(index);
    return QuantLib::IborLeg(schedule, libor)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .inArrears(isInArrears);
}


Leg _CmsLeg(const std::vector<Real>& nominals,
            const Schedule& schedule,
            const boost::shared_ptr<Index>& index,
            const DayCounter& paymentDayCounter = DayCounter(),
            const BusinessDayConvention paymentConvention = Following,
            const std::vector<Natural>& fixingDays = std::vector<Natural>(),
            const std::vector<Real>& gearings = std::vector<Real>(),
            const std::vector<Spread>& spreads = std::vector<Spread>(),
            const std::vector<Rate>& caps = std::vector<Rate>(),
            const std::vector<Rate>& floors = std::vector<Rate>(),
            bool isInArrears = false) {
    boost::shared_ptr<SwapIndex> swapIndex =
        boost::dynamic_pointer_cast<SwapIndex>(index);
    return QuantLib::CmsLeg(schedule, swapIndex)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .inArrears(isInArrears);
}


Leg _CmsZeroLeg(const std::vector<Real>& nominals,
                const Schedule& schedule,
                const boost::shared_ptr<Index>& index,
                const DayCounter& paymentDayCounter = DayCounter(),
                const BusinessDayConvention paymentConvention = Following,
                const std::vector<Natural>& fixingDays = std::vector<Natural>(),
                const std::vector<Real>& gearings = std::vector<Real>(),
                const std::vector<Spread>& spreads = std::vector<Spread>(),
                const std::vector<Rate>& caps = std::vector<Rate>(),
                const std::vector<Rate>& floors = std::vector<Rate>()) {
    boost::shared_ptr<SwapIndex> swapIndex =
        boost::dynamic_pointer_cast<SwapIndex>(index);
    return QuantLib::CmsLeg(schedule, swapIndex)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .withZeroPayments();
}


using QuantLib::CashFlows;
using QuantLib::Duration;

SWIGINTERN Real CashFlows_npv__SWIG_0(Leg const &leg,boost::shared_ptr< YieldTermStructure > const &discountCurve,Spread zSpread,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::npv(leg, discountCurve,
                                            zSpread,
                                            dayCounter,
                                            compounding,
                                            frequency,
                                            includeSettlementDateFlows,
                                            settlementDate,
                                            npvDate);
        }
SWIGINTERN Real CashFlows_npv__SWIG_3(Leg const &leg,Handle< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::npv(leg, **discountCurve,
                                            includeSettlementDateFlows,
                                            settlementDate, npvDate);
        }
SWIGINTERN Real CashFlows_bps__SWIG_0(Leg const &leg,boost::shared_ptr< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::bps(leg, *discountCurve,
                                            includeSettlementDateFlows,
                                            settlementDate, npvDate);
        }
SWIGINTERN Real CashFlows_bps__SWIG_3(Leg const &leg,Handle< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::bps(leg, **discountCurve,
                                            includeSettlementDateFlows,
                                            settlementDate, npvDate);
        }
SWIGINTERN Rate CashFlows_atmRate__SWIG_0(Leg const &leg,boost::shared_ptr< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date(),Real npv=Null< Real >()){
            return QuantLib::CashFlows::atmRate(leg, *discountCurve,
                                                includeSettlementDateFlows,
                                                settlementDate, npvDate,
                                                npv);
        }

using QuantLib::CalibrationHelper;
using QuantLib::SwaptionHelper;
using QuantLib::CapHelper;
using QuantLib::HestonModelHelper;
typedef boost::shared_ptr<CalibrationHelper> SwaptionHelperPtr;
typedef boost::shared_ptr<CalibrationHelper> CapHelperPtr;
typedef boost::shared_ptr<CalibrationHelper> HestonModelHelperPtr;

SWIGINTERN bool boost_shared_ptr_Sl_CalibrationHelper_Sg__isNull(boost::shared_ptr< CalibrationHelper > *self){
                return !(*self);
            }
SWIGINTERN Date boost_shared_ptr_Sl_CalibrationHelper_Sg__swaptionExpiryDate(boost::shared_ptr< CalibrationHelper > *self){
        boost::shared_ptr<SwaptionHelper> s = boost::dynamic_pointer_cast<SwaptionHelper>(*self);
        return s ? s->swaption()->exercise()->date(0) : Null<Date>();
    }
SWIGINTERN Real boost_shared_ptr_Sl_CalibrationHelper_Sg__swaptionStrike(boost::shared_ptr< CalibrationHelper > *self){
        boost::shared_ptr<SwaptionHelper> s = boost::dynamic_pointer_cast<SwaptionHelper>(*self);
        return s ? s->swaption()->underlyingSwap()->fixedRate() : Null<Real>();
    }
SWIGINTERN Real boost_shared_ptr_Sl_CalibrationHelper_Sg__swaptionNominal(boost::shared_ptr< CalibrationHelper > *self){
        boost::shared_ptr<SwaptionHelper> s = boost::dynamic_pointer_cast<SwaptionHelper>(*self);
        return s ? s->swaption()->underlyingSwap()->nominal() : Null<Real>();
    }
SWIGINTERN Date boost_shared_ptr_Sl_CalibrationHelper_Sg__swaptionMaturityDate(boost::shared_ptr< CalibrationHelper > *self){
        boost::shared_ptr<SwaptionHelper> s = boost::dynamic_pointer_cast<SwaptionHelper>(*self);
        return s ? s->swaption()->underlyingSwap()->fixedSchedule().dates().back() : Null<Date>();
    }
SWIGINTERN SwaptionHelperPtr *new_SwaptionHelperPtr__SWIG_0(Period const &maturity,Period const &length,Handle< Quote > const &volatility,IborIndexPtr const &index,Period const &fixedLegTenor,DayCounter const &fixedLegDayCounter,DayCounter const &floatingLegDayCounter,Handle< YieldTermStructure > const &termStructure,CalibrationHelper::CalibrationErrorType errorType=CalibrationHelper::RelativePriceError,Real const strike=Null< Real >(),Real const nominal=1.0,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new SwaptionHelperPtr(
                new SwaptionHelper(maturity,length,volatility,
                                   libor,fixedLegTenor,
                                   fixedLegDayCounter,
                                   floatingLegDayCounter,
                                   termStructure,
                                   errorType,
                                   strike, nominal, 
                                   type, shift));
        }
SWIGINTERN SwaptionHelperPtr *new_SwaptionHelperPtr__SWIG_6(Date const &exerciseDate,Period const &length,Handle< Quote > const &volatility,IborIndexPtr const &index,Period const &fixedLegTenor,DayCounter const &fixedLegDayCounter,DayCounter const &floatingLegDayCounter,Handle< YieldTermStructure > const &termStructure,CalibrationHelper::CalibrationErrorType errorType=CalibrationHelper::RelativePriceError,Real const strike=Null< Real >(),Real const nominal=1.0,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new SwaptionHelperPtr(
                new SwaptionHelper(exerciseDate,length,volatility,
                                   libor,fixedLegTenor,
                                   fixedLegDayCounter,
                                   floatingLegDayCounter,
                                   termStructure,
                                   errorType,
                                   strike, nominal, 
                                   type, shift));
        }
SWIGINTERN SwaptionHelperPtr *new_SwaptionHelperPtr__SWIG_12(Date const &exerciseDate,Date const &endDate,Handle< Quote > const &volatility,IborIndexPtr const &index,Period const &fixedLegTenor,DayCounter const &fixedLegDayCounter,DayCounter const &floatingLegDayCounter,Handle< YieldTermStructure > const &termStructure,CalibrationHelper::CalibrationErrorType errorType=CalibrationHelper::RelativePriceError,Real const strike=Null< Real >(),Real const nominal=1.0,VolatilityType const type=ShiftedLognormal,Real const shift=0.0){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new SwaptionHelperPtr(
                new SwaptionHelper(exerciseDate,endDate,volatility,
                                   libor,fixedLegTenor,
                                   fixedLegDayCounter,
                                   floatingLegDayCounter,
                                   termStructure,
                                   errorType,
                                   strike, nominal, 
                                   type, shift));
        }
SWIGINTERN std::vector< Time > SwaptionHelperPtr_times(SwaptionHelperPtr *self){
            std::list<Time> l;
            (*self)->addTimesTo(l);
            std::vector<Time> v;
            std::copy(l.begin(),l.end(),std::back_inserter(v));
            return v;
        }
SWIGINTERN CapHelperPtr *new_CapHelperPtr__SWIG_0(Period const &length,Handle< Quote > const &volatility,IborIndexPtr const &index,Frequency fixedLegFrequency,DayCounter const &fixedLegDayCounter,bool includeFirstSwaplet,Handle< YieldTermStructure > const &termStructure,CalibrationHelper::CalibrationErrorType errorType=CalibrationHelper::RelativePriceError){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new CapHelperPtr(
                new CapHelper(length,volatility,libor,fixedLegFrequency,
                              fixedLegDayCounter,includeFirstSwaplet,
                              termStructure));
        }
SWIGINTERN std::vector< Time > CapHelperPtr_times(CapHelperPtr *self){
            std::list<Time> l;
            (*self)->addTimesTo(l);
            std::vector<Time> v;
            std::copy(l.begin(),l.end(),std::back_inserter(v));
            return v;
        }
SWIGINTERN HestonModelHelperPtr *new_HestonModelHelperPtr__SWIG_0(Period const &maturity,Calendar const &calendar,Real const s0,Real const strikePrice,Handle< Quote > const &volatility,Handle< YieldTermStructure > const &riskFreeRate,Handle< YieldTermStructure > const &dividendYield,CalibrationHelper::CalibrationErrorType errorType=CalibrationHelper::RelativePriceError){
			return new HestonModelHelperPtr(
				new HestonModelHelper(maturity, calendar, s0, strikePrice,
									  volatility, riskFreeRate, dividendYield,
									  errorType)); 
		}
SWIGINTERN std::vector< boost::shared_ptr< CalibrationHelper > > *new_std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<CalibrationHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<CalibrationHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< CalibrationHelper > std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< CalibrationHelper > const &std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__getitem(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__setitem(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index,boost::shared_ptr< CalibrationHelper > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__AddRange(std::vector< boost::shared_ptr< CalibrationHelper > > *self,std::vector< boost::shared_ptr< CalibrationHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< CalibrationHelper > > *std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__GetRange(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<CalibrationHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Insert(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index,boost::shared_ptr< CalibrationHelper > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index,std::vector< boost::shared_ptr< CalibrationHelper > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< CalibrationHelper > > *std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Repeat(boost::shared_ptr< CalibrationHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<CalibrationHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< CalibrationHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__SetRange(std::vector< boost::shared_ptr< CalibrationHelper > > *self,int index,std::vector< boost::shared_ptr< CalibrationHelper > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Contains(std::vector< boost::shared_ptr< CalibrationHelper > > *self,boost::shared_ptr< CalibrationHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< CalibrationHelper > > *self,boost::shared_ptr< CalibrationHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<CalibrationHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< CalibrationHelper > > *self,boost::shared_ptr< CalibrationHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<CalibrationHelper> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Remove(std::vector< boost::shared_ptr< CalibrationHelper > > *self,boost::shared_ptr< CalibrationHelper > const &value){
        std::vector< boost::shared_ptr<CalibrationHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

using QuantLib::CalibratedModel;

SWIGINTERN bool boost_shared_ptr_Sl_CalibratedModel_Sg__isNull(boost::shared_ptr< CalibratedModel > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_CalibratedModel_Sg__asObservable(boost::shared_ptr< CalibratedModel > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_CalibratedModel_Sg__asObservable(Handle< CalibratedModel > *self){
        return boost::shared_ptr<Observable>(*self);
    }

using QuantLib::TimeGrid;

SWIGINTERN TimeGrid *new_TimeGrid__SWIG_2(std::vector< Time > const &times){
            return new TimeGrid(times.begin(), times.end());
        }
SWIGINTERN TimeGrid *new_TimeGrid__SWIG_3(std::vector< Time > const &times,Size steps){
            return new TimeGrid(times.begin(), times.end(), steps);
        }

using QuantLib::Parameter;
using QuantLib::ConstantParameter;
using QuantLib::NullParameter;
using QuantLib::PiecewiseConstantParameter;


using QuantLib::Option;
using QuantLib::Barrier;


using QuantLib::Payoff;
using QuantLib::StrikedTypePayoff;

SWIGINTERN bool boost_shared_ptr_Sl_Payoff_Sg__isNull(boost::shared_ptr< Payoff > *self){
                return !(*self);
            }

using QuantLib::VanillaOption;
using QuantLib::ForwardVanillaOption;
typedef boost::shared_ptr<Instrument> VanillaOptionPtr;
typedef boost::shared_ptr<Instrument> MultiAssetOptionPtr;

SWIGINTERN VanillaOptionPtr *new_VanillaOptionPtr(boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new VanillaOptionPtr(new VanillaOption(stPayoff,exercise));
        }
SWIGINTERN SampledCurve VanillaOptionPtr_priceCurve(VanillaOptionPtr *self){
            return boost::dynamic_pointer_cast<VanillaOption>(*self)
                ->result<SampledCurve>("priceCurve");
        }
SWIGINTERN Volatility VanillaOptionPtr_impliedVolatility__SWIG_0(VanillaOptionPtr *self,Real targetValue,GeneralizedBlackScholesProcessPtr const &process,Real accuracy=1.0e-4,Size maxEvaluations=100,Volatility minVol=1.0e-4,Volatility maxVol=4.0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return boost::dynamic_pointer_cast<VanillaOption>(*self)
                ->impliedVolatility(targetValue, bsProcess, accuracy,
                                    maxEvaluations, minVol, maxVol);
        }
SWIGINTERN Real VanillaOptionPtr_delta(VanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<VanillaOption>(*self)->delta();
    }
SWIGINTERN Real VanillaOptionPtr_gamma(VanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<VanillaOption>(*self)->gamma();
    }
SWIGINTERN Real VanillaOptionPtr_theta(VanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<VanillaOption>(*self)->theta();
    }
SWIGINTERN Real VanillaOptionPtr_thetaPerDay(VanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<VanillaOption>(*self)->thetaPerDay();
    }
SWIGINTERN Real VanillaOptionPtr_vega(VanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<VanillaOption>(*self)->vega();
    }
SWIGINTERN Real VanillaOptionPtr_rho(VanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<VanillaOption>(*self)->rho();
    }
SWIGINTERN Real VanillaOptionPtr_dividendRho(VanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<VanillaOption>(*self)->dividendRho();
    }
SWIGINTERN Real VanillaOptionPtr_strikeSensitivity(VanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<VanillaOption>(*self)->strikeSensitivity();
    }

using QuantLib::EuropeanOption;
typedef boost::shared_ptr<Instrument> EuropeanOptionPtr;

SWIGINTERN EuropeanOptionPtr *new_EuropeanOptionPtr(boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new EuropeanOptionPtr(new EuropeanOption(stPayoff,exercise));
        }

using QuantLib::ForwardVanillaOption;
typedef boost::shared_ptr<Instrument> ForwardVanillaOptionPtr;

SWIGINTERN ForwardVanillaOptionPtr *new_ForwardVanillaOptionPtr(Real moneyness,Date resetDate,boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new ForwardVanillaOptionPtr(
                                new ForwardVanillaOption(moneyness, resetDate,
                                                         stPayoff, exercise));
        }

using QuantLib::QuantoVanillaOption;
typedef boost::shared_ptr<Instrument> QuantoVanillaOptionPtr;

SWIGINTERN QuantoVanillaOptionPtr *new_QuantoVanillaOptionPtr(boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new QuantoVanillaOptionPtr(
                                 new QuantoVanillaOption(stPayoff, exercise));
        }
SWIGINTERN Real QuantoVanillaOptionPtr_qvega(QuantoVanillaOptionPtr *self){
            return boost::dynamic_pointer_cast<QuantoVanillaOption>(*self)
                ->qvega();
        }
SWIGINTERN Real QuantoVanillaOptionPtr_qrho(QuantoVanillaOptionPtr *self){
            return boost::dynamic_pointer_cast<QuantoVanillaOption>(*self)
                ->qrho();
        }
SWIGINTERN Real QuantoVanillaOptionPtr_qlambda(QuantoVanillaOptionPtr *self){
            return boost::dynamic_pointer_cast<QuantoVanillaOption>(*self)
                ->qlambda();
        }

using QuantLib::QuantoForwardVanillaOption;
typedef boost::shared_ptr<Instrument> QuantoForwardVanillaOptionPtr;

SWIGINTERN QuantoForwardVanillaOptionPtr *new_QuantoForwardVanillaOptionPtr(Real moneyness,Date resetDate,boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new QuantoForwardVanillaOptionPtr(
                          new QuantoForwardVanillaOption(moneyness, resetDate,
                                                         stPayoff, exercise));
        }

using QuantLib::MultiAssetOption;

SWIGINTERN Real MultiAssetOptionPtr_delta(MultiAssetOptionPtr *self){
            return boost::dynamic_pointer_cast<MultiAssetOption>(*self)
                ->delta();
        }
SWIGINTERN Real MultiAssetOptionPtr_gamma(MultiAssetOptionPtr *self){
            return boost::dynamic_pointer_cast<MultiAssetOption>(*self)
                ->gamma();
        }
SWIGINTERN Real MultiAssetOptionPtr_theta(MultiAssetOptionPtr *self){
            return boost::dynamic_pointer_cast<MultiAssetOption>(*self)
                ->theta();
        }
SWIGINTERN Real MultiAssetOptionPtr_vega(MultiAssetOptionPtr *self){
            return boost::dynamic_pointer_cast<MultiAssetOption>(*self)->vega();
        }
SWIGINTERN Real MultiAssetOptionPtr_rho(MultiAssetOptionPtr *self){
            return boost::dynamic_pointer_cast<MultiAssetOption>(*self)->rho();
        }
SWIGINTERN Real MultiAssetOptionPtr_dividendRho(MultiAssetOptionPtr *self){
            return boost::dynamic_pointer_cast<MultiAssetOption>(*self)
                ->dividendRho();
        }

using QuantLib::AnalyticEuropeanEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticEuropeanEnginePtr;

SWIGINTERN AnalyticEuropeanEnginePtr *new_AnalyticEuropeanEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticEuropeanEnginePtr(
                                       new AnalyticEuropeanEngine(bsProcess));
        }

using QuantLib::HestonModel;
typedef boost::shared_ptr<CalibratedModel> HestonModelPtr;

SWIGINTERN HestonModelPtr *new_HestonModelPtr(HestonProcessPtr const &process){

            boost::shared_ptr<HestonProcess> hProcess =
                 boost::dynamic_pointer_cast<HestonProcess>(process);
            QL_REQUIRE(hProcess, "Heston process required");

            return new HestonModelPtr(new HestonModel(hProcess));
        }
SWIGINTERN Real HestonModelPtr_theta(HestonModelPtr const *self){
            return boost::dynamic_pointer_cast<HestonModel>(*self)->theta();
        }
SWIGINTERN Real HestonModelPtr_kappa(HestonModelPtr const *self){
            return boost::dynamic_pointer_cast<HestonModel>(*self)->kappa();
        }
SWIGINTERN Real HestonModelPtr_sigma(HestonModelPtr const *self){
            return boost::dynamic_pointer_cast<HestonModel>(*self)->sigma();
        }
SWIGINTERN Real HestonModelPtr_rho(HestonModelPtr const *self){
            return boost::dynamic_pointer_cast<HestonModel>(*self)->rho();
        }
SWIGINTERN Real HestonModelPtr_v0(HestonModelPtr const *self){
            return boost::dynamic_pointer_cast<HestonModel>(*self)->v0();
        }

using QuantLib::PiecewiseTimeDependentHestonModel;
typedef boost::shared_ptr<CalibratedModel> PiecewiseTimeDependentHestonModelPtr;

SWIGINTERN PiecewiseTimeDependentHestonModelPtr *new_PiecewiseTimeDependentHestonModelPtr(Handle< YieldTermStructure > const &riskFreeRate,Handle< YieldTermStructure > const &dividendYield,Handle< Quote > const &s0,Real v0,Parameter const &theta,Parameter const &kappa,Parameter const &sigma,Parameter const &rho,TimeGrid const &timeGrid){
            return new PiecewiseTimeDependentHestonModelPtr (
                new PiecewiseTimeDependentHestonModel(riskFreeRate,
                    dividendYield, s0, v0, theta, kappa, 
                    sigma, rho, timeGrid));
        }
SWIGINTERN Real PiecewiseTimeDependentHestonModelPtr_theta(PiecewiseTimeDependentHestonModelPtr const *self,Time t){ 
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->theta(t);
        }
SWIGINTERN Real PiecewiseTimeDependentHestonModelPtr_kappa(PiecewiseTimeDependentHestonModelPtr const *self,Time t){
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->kappa(t);
        }
SWIGINTERN Real PiecewiseTimeDependentHestonModelPtr_sigma(PiecewiseTimeDependentHestonModelPtr const *self,Time t){
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->sigma(t);
        }
SWIGINTERN Real PiecewiseTimeDependentHestonModelPtr_rho(PiecewiseTimeDependentHestonModelPtr const *self,Time t){ 
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->rho(t);
        }
SWIGINTERN Real PiecewiseTimeDependentHestonModelPtr_v0(PiecewiseTimeDependentHestonModelPtr const *self){ 
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->v0();
        }
SWIGINTERN Real PiecewiseTimeDependentHestonModelPtr_s0(PiecewiseTimeDependentHestonModelPtr const *self){ 
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->s0();
        }
SWIGINTERN TimeGrid const &PiecewiseTimeDependentHestonModelPtr_timeGrid(PiecewiseTimeDependentHestonModelPtr const *self){
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->timeGrid();
        }
SWIGINTERN Handle< YieldTermStructure > const &PiecewiseTimeDependentHestonModelPtr_dividendYield(PiecewiseTimeDependentHestonModelPtr const *self){
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->dividendYield();
        }
SWIGINTERN Handle< YieldTermStructure > const &PiecewiseTimeDependentHestonModelPtr_riskFreeRate(PiecewiseTimeDependentHestonModelPtr const *self){
            return boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(*self)->riskFreeRate();
        }

using QuantLib::AnalyticHestonEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticHestonEnginePtr;

SWIGINTERN AnalyticHestonEnginePtr *new_AnalyticHestonEnginePtr__SWIG_0(HestonModelPtr const &model,Size integrationOrder=144){
            boost::shared_ptr<HestonModel> hModel =
                 boost::dynamic_pointer_cast<HestonModel>(model);
            QL_REQUIRE(hModel, "Heston model required");

            return new AnalyticHestonEnginePtr(
                new AnalyticHestonEngine(hModel, integrationOrder));
        }
SWIGINTERN AnalyticHestonEnginePtr *new_AnalyticHestonEnginePtr__SWIG_2(HestonModelPtr const &model,Real relTolerance,Size maxEvaluations){
            boost::shared_ptr<HestonModel> hModel =
                 boost::dynamic_pointer_cast<HestonModel>(model);
            QL_REQUIRE(hModel, "Heston model required");

            return new AnalyticHestonEnginePtr(
                new AnalyticHestonEngine(hModel, relTolerance,maxEvaluations));
        }

using QuantLib::AnalyticPTDHestonEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticPTDHestonEnginePtr;

SWIGINTERN AnalyticPTDHestonEnginePtr *new_AnalyticPTDHestonEnginePtr__SWIG_0(PiecewiseTimeDependentHestonModelPtr const &model,Real relTolerance,Size maxEvaluations){
                const boost::shared_ptr<PiecewiseTimeDependentHestonModel> hmodel = 
                    boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(model);
                return new AnalyticPTDHestonEnginePtr(
                    new AnalyticPTDHestonEngine(hmodel, relTolerance, maxEvaluations)
            );
        }
SWIGINTERN AnalyticPTDHestonEnginePtr *new_AnalyticPTDHestonEnginePtr__SWIG_1(PiecewiseTimeDependentHestonModelPtr const &model,Size integrationOrder=144){
                const boost::shared_ptr<PiecewiseTimeDependentHestonModel> hmodel = 
                    boost::dynamic_pointer_cast<PiecewiseTimeDependentHestonModel>(model);
                return new AnalyticPTDHestonEnginePtr(
                    new AnalyticPTDHestonEngine(hmodel, integrationOrder)
            );
        }

using QuantLib::BatesModel;
typedef boost::shared_ptr<CalibratedModel> BatesModelPtr;

SWIGINTERN BatesModelPtr *new_BatesModelPtr(BatesProcessPtr const &process){

            boost::shared_ptr<BatesProcess> bProcess =
                 boost::dynamic_pointer_cast<BatesProcess>(process);
            QL_REQUIRE(bProcess, "Bates process required");

            return new BatesModelPtr(new BatesModel(bProcess));
        }
SWIGINTERN Real BatesModelPtr_nu(BatesModelPtr const *self){
            return boost::dynamic_pointer_cast<BatesModel>(*self)->nu();
        }
SWIGINTERN Real BatesModelPtr_delta(BatesModelPtr const *self){
            return boost::dynamic_pointer_cast<BatesModel>(*self)->delta();
        }
SWIGINTERN Real BatesModelPtr_lambda(BatesModelPtr const *self){
            return boost::dynamic_pointer_cast<BatesModel>(*self)->lambda();
        }

using QuantLib::BatesEngine;
typedef boost::shared_ptr<PricingEngine> BatesEnginePtr;

SWIGINTERN BatesEnginePtr *new_BatesEnginePtr__SWIG_0(BatesModelPtr const &model,Size integrationOrder=144){
            boost::shared_ptr<BatesModel> bModel =
                 boost::dynamic_pointer_cast<BatesModel>(model);
            QL_REQUIRE(bModel, "Bates model required");

            return new BatesEnginePtr(
                new BatesEngine(bModel, integrationOrder));
        }
SWIGINTERN BatesEnginePtr *new_BatesEnginePtr__SWIG_2(BatesModelPtr const &model,Real relTolerance,Size maxEvaluations){
            boost::shared_ptr<BatesModel> bModel =
                 boost::dynamic_pointer_cast<BatesModel>(model);
            QL_REQUIRE(bModel, "Bates model required");

            return new BatesEnginePtr(
                new BatesEngine(bModel, relTolerance,maxEvaluations));
        }

using QuantLib::IntegralEngine;
typedef boost::shared_ptr<PricingEngine> IntegralEnginePtr;

SWIGINTERN IntegralEnginePtr *new_IntegralEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new IntegralEnginePtr(new IntegralEngine(bsProcess));
        }

using QuantLib::FDBermudanEngine;
typedef boost::shared_ptr<PricingEngine> FDBermudanEnginePtr;

SWIGINTERN FDBermudanEnginePtr *new_FDBermudanEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,Size timeSteps=100,Size gridPoints=100,bool timeDependent=false){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FDBermudanEnginePtr(
                            new FDBermudanEngine<>(bsProcess,timeSteps,
                                                   gridPoints,timeDependent));
        }

using QuantLib::FDEuropeanEngine;
typedef boost::shared_ptr<PricingEngine> FDEuropeanEnginePtr;

SWIGINTERN FDEuropeanEnginePtr *new_FDEuropeanEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,Size timeSteps=100,Size gridPoints=100,bool timeDependent=false){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FDEuropeanEnginePtr(
                            new FDEuropeanEngine<>(bsProcess,timeSteps,
                                                   gridPoints,timeDependent));
        }

using QuantLib::BinomialVanillaEngine;
using QuantLib::CoxRossRubinstein;
using QuantLib::JarrowRudd;
using QuantLib::AdditiveEQPBinomialTree;
using QuantLib::Trigeorgis;
using QuantLib::Tian;
using QuantLib::LeisenReimer;
using QuantLib::Joshi4;
typedef boost::shared_ptr<PricingEngine> BinomialVanillaEnginePtr;

SWIGINTERN BinomialVanillaEnginePtr *new_BinomialVanillaEnginePtr(GeneralizedBlackScholesProcessPtr const &process,std::string const &type,Size steps){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(type);
            if (s == "crr" || s == "coxrossrubinstein")
                return new BinomialVanillaEnginePtr(
                    new BinomialVanillaEngine<CoxRossRubinstein>(
                                                            bsProcess,steps));
            else if (s == "jr" || s == "jarrowrudd")
                return new BinomialVanillaEnginePtr(
                    new BinomialVanillaEngine<JarrowRudd>(bsProcess,steps));
            else if (s == "eqp" || s == "additiveeqpbinomialtree")
                return new BinomialVanillaEnginePtr(
                    new BinomialVanillaEngine<AdditiveEQPBinomialTree>(
                                                            bsProcess,steps));
            else if (s == "trigeorgis")
                return new BinomialVanillaEnginePtr(
                    new BinomialVanillaEngine<Trigeorgis>(bsProcess,steps));
            else if (s == "tian")
                return new BinomialVanillaEnginePtr(
                    new BinomialVanillaEngine<Tian>(bsProcess,steps));
            else if (s == "lr" || s == "leisenreimer")
                return new BinomialVanillaEnginePtr(
                    new BinomialVanillaEngine<LeisenReimer>(bsProcess,steps));
            else if (s == "j4" || s == "joshi4")
                return new BinomialVanillaEnginePtr(
                    new BinomialVanillaEngine<Joshi4>(bsProcess,steps));
            else
                QL_FAIL("unknown binomial engine type: "+s);
        }

using QuantLib::MCEuropeanEngine;
using QuantLib::PseudoRandom;
using QuantLib::LowDiscrepancy;
typedef boost::shared_ptr<PricingEngine> MCEuropeanEnginePtr;

SWIGINTERN MCEuropeanEnginePtr *new_MCEuropeanEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,std::string const &traits,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            if (s == "pseudorandom" || s == "pr")
                return new MCEuropeanEnginePtr(
                         new MCEuropeanEngine<PseudoRandom>(bsProcess,
                                                            timeSteps,
                                                            timeStepsPerYear,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCEuropeanEnginePtr(
                       new MCEuropeanEngine<LowDiscrepancy>(bsProcess,
                                                            timeSteps,
                                                            timeStepsPerYear,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::FDAmericanEngine;
using QuantLib::FDShoutEngine;
typedef boost::shared_ptr<PricingEngine> FDAmericanEnginePtr;
typedef boost::shared_ptr<PricingEngine> FDShoutEnginePtr;

SWIGINTERN FDAmericanEnginePtr *new_FDAmericanEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,Size timeSteps=100,Size gridPoints=100,bool timeDependent=false){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FDAmericanEnginePtr(
                            new FDAmericanEngine<>(bsProcess,timeSteps,
                                                   gridPoints,timeDependent));
        }

using QuantLib::FdBlackScholesVanillaEngine;
typedef boost::shared_ptr<PricingEngine> FdBlackScholesVanillaEnginePtr;

SWIGINTERN FdBlackScholesVanillaEnginePtr *new_FdBlackScholesVanillaEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,Size tGrid=100,Size xGrid=100,Size dampingSteps=0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FdBlackScholesVanillaEnginePtr(
                            new FdBlackScholesVanillaEngine( bsProcess,tGrid, xGrid, dampingSteps));
        }

using QuantLib::FdBatesVanillaEngine;
typedef boost::shared_ptr<PricingEngine> FdBatesVanillaEnginePtr;

SWIGINTERN FdBatesVanillaEnginePtr *new_FdBatesVanillaEnginePtr__SWIG_0(BatesModelPtr const &model,Size tGrid=100,Size xGrid=100,Size vGrid=50,Size dampingSteps=0){
            boost::shared_ptr<BatesModel> bModel =
                 boost::dynamic_pointer_cast<BatesModel>(model);
            QL_REQUIRE(bModel, "Bates model required");
            return new FdBatesVanillaEnginePtr(
                               new FdBatesVanillaEngine(bModel, tGrid, xGrid,
                                                        vGrid, dampingSteps));
        }

using QuantLib::ContinuousArithmeticAsianLevyEngine;
typedef boost::shared_ptr<PricingEngine> ContinuousArithmeticAsianLevyEnginePtr;

SWIGINTERN ContinuousArithmeticAsianLevyEnginePtr *new_ContinuousArithmeticAsianLevyEnginePtr(GeneralizedBlackScholesProcessPtr const &process,Handle< Quote > const &runningAverage,Date const &startDate){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new ContinuousArithmeticAsianLevyEnginePtr(
                            new ContinuousArithmeticAsianLevyEngine(bsProcess,runningAverage, startDate));
        }

using QuantLib::FdBlackScholesAsianEngine;
typedef boost::shared_ptr<PricingEngine> FdBlackScholesAsianEnginePtr;

SWIGINTERN FdBlackScholesAsianEnginePtr *new_FdBlackScholesAsianEnginePtr(GeneralizedBlackScholesProcessPtr const &process,Size tGrid,Size xGrid,Size aGrid){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FdBlackScholesAsianEnginePtr(
                            new FdBlackScholesAsianEngine(bsProcess,tGrid, xGrid, aGrid));
        }
SWIGINTERN FDShoutEnginePtr *new_FDShoutEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,Size timeSteps=100,Size gridPoints=100,bool timeDependent=false){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FDShoutEnginePtr(
                               new FDShoutEngine<>(bsProcess,timeSteps,
                                                   gridPoints,timeDependent));
        }

using QuantLib::BaroneAdesiWhaleyApproximationEngine;
typedef boost::shared_ptr<PricingEngine>
    BaroneAdesiWhaleyApproximationEnginePtr;

SWIGINTERN BaroneAdesiWhaleyApproximationEnginePtr *new_BaroneAdesiWhaleyApproximationEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new BaroneAdesiWhaleyApproximationEnginePtr(
                         new BaroneAdesiWhaleyApproximationEngine(bsProcess));
        }

using QuantLib::BjerksundStenslandApproximationEngine;
typedef boost::shared_ptr<PricingEngine>
    BjerksundStenslandApproximationEnginePtr;

SWIGINTERN BjerksundStenslandApproximationEnginePtr *new_BjerksundStenslandApproximationEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new BjerksundStenslandApproximationEnginePtr(
                        new BjerksundStenslandApproximationEngine(bsProcess));
        }

using QuantLib::AnalyticDigitalAmericanEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticDigitalAmericanEnginePtr;

SWIGINTERN AnalyticDigitalAmericanEnginePtr *new_AnalyticDigitalAmericanEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticDigitalAmericanEnginePtr(
                                new AnalyticDigitalAmericanEngine(bsProcess));
        }

using QuantLib::AnalyticDigitalAmericanKOEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticDigitalAmericanKOEnginePtr;

SWIGINTERN AnalyticDigitalAmericanKOEnginePtr *new_AnalyticDigitalAmericanKOEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticDigitalAmericanKOEnginePtr(
                                new AnalyticDigitalAmericanKOEngine(bsProcess));
        }

using QuantLib::DividendVanillaOption;
typedef boost::shared_ptr<Instrument> DividendVanillaOptionPtr;

SWIGINTERN DividendVanillaOptionPtr *new_DividendVanillaOptionPtr(boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise,std::vector< Date > const &dividendDates,std::vector< Real > const &dividends){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new DividendVanillaOptionPtr(
                          new DividendVanillaOption(stPayoff,exercise,
                                                    dividendDates,dividends));
        }
SWIGINTERN SampledCurve DividendVanillaOptionPtr_priceCurve(DividendVanillaOptionPtr *self){
            return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)
                ->result<SampledCurve>("priceCurve");
        }
SWIGINTERN Volatility DividendVanillaOptionPtr_impliedVolatility__SWIG_0(DividendVanillaOptionPtr *self,Real targetValue,GeneralizedBlackScholesProcessPtr const &process,Real accuracy=1.0e-4,Size maxEvaluations=100,Volatility minVol=1.0e-4,Volatility maxVol=4.0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)
                ->impliedVolatility(targetValue, bsProcess, accuracy,
                                    maxEvaluations, minVol, maxVol);
        }
SWIGINTERN Real DividendVanillaOptionPtr_delta(DividendVanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)->delta();
    }
SWIGINTERN Real DividendVanillaOptionPtr_gamma(DividendVanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)->gamma();
    }
SWIGINTERN Real DividendVanillaOptionPtr_theta(DividendVanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)->theta();
    }
SWIGINTERN Real DividendVanillaOptionPtr_thetaPerDay(DividendVanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)->thetaPerDay();
    }
SWIGINTERN Real DividendVanillaOptionPtr_vega(DividendVanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)->vega();
    }
SWIGINTERN Real DividendVanillaOptionPtr_rho(DividendVanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)->rho();
    }
SWIGINTERN Real DividendVanillaOptionPtr_dividendRho(DividendVanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)->dividendRho();
    }
SWIGINTERN Real DividendVanillaOptionPtr_strikeSensitivity(DividendVanillaOptionPtr *self){
        return boost::dynamic_pointer_cast<DividendVanillaOption>(*self)->strikeSensitivity();
    }

using QuantLib::AnalyticDividendEuropeanEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticDividendEuropeanEnginePtr;

SWIGINTERN AnalyticDividendEuropeanEnginePtr *new_AnalyticDividendEuropeanEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticDividendEuropeanEnginePtr(
                               new AnalyticDividendEuropeanEngine(bsProcess));
        }

using QuantLib::FDDividendEuropeanEngine;
using QuantLib::FDDividendAmericanEngine;
typedef boost::shared_ptr<PricingEngine> FDDividendEuropeanEnginePtr;
typedef boost::shared_ptr<PricingEngine> FDDividendAmericanEnginePtr;

SWIGINTERN FDDividendEuropeanEnginePtr *new_FDDividendEuropeanEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,Size timeSteps=100,Size gridPoints=100,bool timeDependent=false){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FDDividendEuropeanEnginePtr(
                   new FDDividendEuropeanEngine<>(bsProcess,timeSteps,
                                                  gridPoints, timeDependent));
        }
SWIGINTERN FDDividendAmericanEnginePtr *new_FDDividendAmericanEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,Size timeSteps=100,Size gridPoints=100,bool timeDependent=false){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FDDividendAmericanEnginePtr(
                   new FDDividendAmericanEngine<>(bsProcess,timeSteps,
                                                  gridPoints, timeDependent));
        }

using QuantLib::BarrierOption;
typedef boost::shared_ptr<Instrument> BarrierOptionPtr;

SWIGINTERN BarrierOptionPtr *new_BarrierOptionPtr(Barrier::Type barrierType,Real barrier,Real rebate,boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new BarrierOptionPtr(
                               new BarrierOption(barrierType, barrier, rebate,
                                                 stPayoff,exercise));
        }
SWIGINTERN SampledCurve BarrierOptionPtr_priceCurve(BarrierOptionPtr *self){
            return boost::dynamic_pointer_cast<BarrierOption>(*self)
                ->result<SampledCurve>("priceCurve");
        }
SWIGINTERN Volatility BarrierOptionPtr_impliedVolatility__SWIG_0(BarrierOptionPtr *self,Real targetValue,GeneralizedBlackScholesProcessPtr const &process,Real accuracy=1.0e-4,Size maxEvaluations=100,Volatility minVol=1.0e-4,Volatility maxVol=4.0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return boost::dynamic_pointer_cast<BarrierOption>(*self)
                 ->impliedVolatility(targetValue, bsProcess, accuracy,
                                     maxEvaluations, minVol, maxVol);
        }
SWIGINTERN Real BarrierOptionPtr_delta(BarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<BarrierOption>(*self)->delta();
    }
SWIGINTERN Real BarrierOptionPtr_gamma(BarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<BarrierOption>(*self)->gamma();
    }
SWIGINTERN Real BarrierOptionPtr_theta(BarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<BarrierOption>(*self)->theta();
    }
SWIGINTERN Real BarrierOptionPtr_thetaPerDay(BarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<BarrierOption>(*self)->thetaPerDay();
    }
SWIGINTERN Real BarrierOptionPtr_vega(BarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<BarrierOption>(*self)->vega();
    }
SWIGINTERN Real BarrierOptionPtr_rho(BarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<BarrierOption>(*self)->rho();
    }
SWIGINTERN Real BarrierOptionPtr_dividendRho(BarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<BarrierOption>(*self)->dividendRho();
    }
SWIGINTERN Real BarrierOptionPtr_strikeSensitivity(BarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<BarrierOption>(*self)->strikeSensitivity();
    }

using QuantLib::AnalyticBarrierEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticBarrierEnginePtr;

SWIGINTERN AnalyticBarrierEnginePtr *new_AnalyticBarrierEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticBarrierEnginePtr(
                                        new AnalyticBarrierEngine(bsProcess));
        }

using QuantLib::MCBarrierEngine;
typedef boost::shared_ptr<PricingEngine> MCBarrierEnginePtr;

SWIGINTERN MCBarrierEnginePtr *new_MCBarrierEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,std::string const &traits,Size timeSteps=Null< Size >(),Size timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),bool isBiased=false,BigInteger seed=0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            if (s == "pseudorandom" || s == "pr")
                return new MCBarrierEnginePtr(
                         new MCBarrierEngine<PseudoRandom>(bsProcess,
                                                           timeSteps,
                                                           timeStepsPerYear,
                                                           brownianBridge,
                                                           antitheticVariate,
                                                           requiredSamples,
                                                           requiredTolerance,
                                                           maxSamples,
                                                           isBiased,
                                                           seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCBarrierEnginePtr(
                       new MCBarrierEngine<LowDiscrepancy>(bsProcess,
                                                           timeSteps,
                                                           timeStepsPerYear,
                                                           brownianBridge,
                                                           antitheticVariate,
                                                           requiredSamples,
                                                           requiredTolerance,
                                                           maxSamples,
                                                           isBiased,
                                                           seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::FdmSchemeDesc;


using QuantLib::FdBlackScholesBarrierEngine;
typedef boost::shared_ptr<PricingEngine> FdBlackScholesBarrierEnginePtr;

SWIGINTERN FdBlackScholesBarrierEnginePtr *new_FdBlackScholesBarrierEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,Size tGrid=100,Size xGrid=100,Size dampingSteps=0,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Douglas(),bool localVol=false,Real illegalLocalVolOverwrite=-Null< Real >()){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new FdBlackScholesBarrierEnginePtr(
                            new FdBlackScholesBarrierEngine(bsProcess,
                                                              tGrid,  xGrid, dampingSteps, 
                                                              schemeDesc, localVol,
                                                              illegalLocalVolOverwrite));
        }

using QuantLib::AnalyticBinaryBarrierEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticBinaryBarrierEnginePtr;

SWIGINTERN AnalyticBinaryBarrierEnginePtr *new_AnalyticBinaryBarrierEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticBinaryBarrierEnginePtr(
                                        new AnalyticBinaryBarrierEngine(bsProcess));
        }

using QuantLib::BinomialBarrierEngine;
using QuantLib::DiscretizedDermanKaniBarrierOption;
typedef boost::shared_ptr<PricingEngine> BinomialBarrierEnginePtr;

SWIGINTERN BinomialBarrierEnginePtr *new_BinomialBarrierEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,std::string const &type,Size steps,Size max_steps=0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(type);
            if (s == "crr" || s == "coxrossrubinstein")
                return new BinomialBarrierEnginePtr(
                    new BinomialBarrierEngine<CoxRossRubinstein,
                                          DiscretizedDermanKaniBarrierOption>(
                                                  bsProcess,steps,max_steps));
            else if (s == "jr" || s == "jarrowrudd")
                return new BinomialBarrierEnginePtr(
                    new BinomialBarrierEngine<JarrowRudd,
                                          DiscretizedDermanKaniBarrierOption>(
                                                  bsProcess,steps,max_steps));
            else if (s == "eqp" || s == "additiveeqpbinomialtree")
                return new BinomialBarrierEnginePtr(
                    new BinomialBarrierEngine<AdditiveEQPBinomialTree,
                                          DiscretizedDermanKaniBarrierOption>(
                                                  bsProcess,steps,max_steps));
            else if (s == "trigeorgis")
                return new BinomialBarrierEnginePtr(
                    new BinomialBarrierEngine<Trigeorgis,
                                          DiscretizedDermanKaniBarrierOption>(
                                                  bsProcess,steps,max_steps));
            else if (s == "tian")
                return new BinomialBarrierEnginePtr(
                    new BinomialBarrierEngine<Tian,
                                          DiscretizedDermanKaniBarrierOption>(
                                                  bsProcess,steps,max_steps));
            else if (s == "lr" || s == "leisenreimer")
                return new BinomialBarrierEnginePtr(
                    new BinomialBarrierEngine<LeisenReimer,
                                          DiscretizedDermanKaniBarrierOption>(
                                                  bsProcess,steps,max_steps));
            else if (s == "j4" || s == "joshi4")
                return new BinomialBarrierEnginePtr(
                    new BinomialBarrierEngine<Joshi4,
                                          DiscretizedDermanKaniBarrierOption>(
                                                  bsProcess,steps,max_steps));
            else
                QL_FAIL("unknown binomial barrier engine type: "+s);
        }

using QuantLib::QuantoEngine;
using QuantLib::ForwardVanillaEngine;
typedef boost::shared_ptr<PricingEngine> ForwardEuropeanEnginePtr;
typedef boost::shared_ptr<PricingEngine> QuantoEuropeanEnginePtr;
typedef boost::shared_ptr<PricingEngine> QuantoForwardEuropeanEnginePtr;

SWIGINTERN ForwardEuropeanEnginePtr *new_ForwardEuropeanEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new ForwardEuropeanEnginePtr(
                 new ForwardVanillaEngine<AnalyticEuropeanEngine>(bsProcess));
        }
SWIGINTERN QuantoEuropeanEnginePtr *new_QuantoEuropeanEnginePtr(GeneralizedBlackScholesProcessPtr const &process,Handle< YieldTermStructure > const &foreignRiskFreeRate,Handle< BlackVolTermStructure > const &exchangeRateVolatility,Handle< Quote > const &correlation){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new QuantoEuropeanEnginePtr(
                new QuantoEngine<VanillaOption,AnalyticEuropeanEngine>(
                                                       bsProcess,
                                                       foreignRiskFreeRate,
                                                       exchangeRateVolatility,
                                                       correlation));
        }
SWIGINTERN QuantoForwardEuropeanEnginePtr *new_QuantoForwardEuropeanEnginePtr(GeneralizedBlackScholesProcessPtr const &process,Handle< YieldTermStructure > const &foreignRiskFreeRate,Handle< BlackVolTermStructure > const &exchangeRateVolatility,Handle< Quote > const &correlation){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new QuantoForwardEuropeanEnginePtr(
                new QuantoEngine<ForwardVanillaOption,AnalyticEuropeanEngine>(
                                                       bsProcess,
                                                       foreignRiskFreeRate,
                                                       exchangeRateVolatility,
                                                       correlation));
        }

using QuantLib::BlackCalculator;

SWIGINTERN BlackCalculator *new_BlackCalculator__SWIG_0(boost::shared_ptr< Payoff > const &payoff,Real forward,Real stdDev,Real discount=1.0){

            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);

            QL_REQUIRE(stPayoff, "wrong payoff given");

            return new BlackCalculator(stPayoff,forward,stdDev,discount);
        }

using QuantLib::Average;
using QuantLib::ContinuousAveragingAsianOption;
using QuantLib::DiscreteAveragingAsianOption;
typedef boost::shared_ptr<Instrument> ContinuousAveragingAsianOptionPtr;
typedef boost::shared_ptr<Instrument> DiscreteAveragingAsianOptionPtr;

SWIGINTERN ContinuousAveragingAsianOptionPtr *new_ContinuousAveragingAsianOptionPtr(Average::Type averageType,boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new ContinuousAveragingAsianOptionPtr(
                       new ContinuousAveragingAsianOption(averageType,
                                                          stPayoff,exercise));
        }
SWIGINTERN Real ContinuousAveragingAsianOptionPtr_delta(ContinuousAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<ContinuousAveragingAsianOption>(*self)->delta();
    }
SWIGINTERN Real ContinuousAveragingAsianOptionPtr_gamma(ContinuousAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<ContinuousAveragingAsianOption>(*self)->gamma();
    }
SWIGINTERN Real ContinuousAveragingAsianOptionPtr_theta(ContinuousAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<ContinuousAveragingAsianOption>(*self)->theta();
    }
SWIGINTERN Real ContinuousAveragingAsianOptionPtr_thetaPerDay(ContinuousAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<ContinuousAveragingAsianOption>(*self)->thetaPerDay();
    }
SWIGINTERN Real ContinuousAveragingAsianOptionPtr_vega(ContinuousAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<ContinuousAveragingAsianOption>(*self)->vega();
    }
SWIGINTERN Real ContinuousAveragingAsianOptionPtr_rho(ContinuousAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<ContinuousAveragingAsianOption>(*self)->rho();
    }
SWIGINTERN Real ContinuousAveragingAsianOptionPtr_dividendRho(ContinuousAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<ContinuousAveragingAsianOption>(*self)->dividendRho();
    }
SWIGINTERN Real ContinuousAveragingAsianOptionPtr_strikeSensitivity(ContinuousAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<ContinuousAveragingAsianOption>(*self)->strikeSensitivity();
    }
SWIGINTERN DiscreteAveragingAsianOptionPtr *new_DiscreteAveragingAsianOptionPtr(Average::Type averageType,Real runningAccumulator,Size pastFixings,std::vector< Date > const &fixingDates,boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new DiscreteAveragingAsianOptionPtr(
                          new DiscreteAveragingAsianOption(averageType,
                                                           runningAccumulator,
                                                           pastFixings,
                                                           fixingDates,
                                                           stPayoff,
                                                           exercise));
        }
SWIGINTERN Real DiscreteAveragingAsianOptionPtr_delta(DiscreteAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<DiscreteAveragingAsianOption>(*self)->delta();
    }
SWIGINTERN Real DiscreteAveragingAsianOptionPtr_gamma(DiscreteAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<DiscreteAveragingAsianOption>(*self)->gamma();
    }
SWIGINTERN Real DiscreteAveragingAsianOptionPtr_theta(DiscreteAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<DiscreteAveragingAsianOption>(*self)->theta();
    }
SWIGINTERN Real DiscreteAveragingAsianOptionPtr_thetaPerDay(DiscreteAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<DiscreteAveragingAsianOption>(*self)->thetaPerDay();
    }
SWIGINTERN Real DiscreteAveragingAsianOptionPtr_vega(DiscreteAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<DiscreteAveragingAsianOption>(*self)->vega();
    }
SWIGINTERN Real DiscreteAveragingAsianOptionPtr_rho(DiscreteAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<DiscreteAveragingAsianOption>(*self)->rho();
    }
SWIGINTERN Real DiscreteAveragingAsianOptionPtr_dividendRho(DiscreteAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<DiscreteAveragingAsianOption>(*self)->dividendRho();
    }
SWIGINTERN Real DiscreteAveragingAsianOptionPtr_strikeSensitivity(DiscreteAveragingAsianOptionPtr *self){
        return boost::dynamic_pointer_cast<DiscreteAveragingAsianOption>(*self)->strikeSensitivity();
    }

using QuantLib::AnalyticContinuousGeometricAveragePriceAsianEngine;
typedef boost::shared_ptr<PricingEngine>
    AnalyticContinuousGeometricAveragePriceAsianEnginePtr;

SWIGINTERN AnalyticContinuousGeometricAveragePriceAsianEnginePtr *new_AnalyticContinuousGeometricAveragePriceAsianEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticContinuousGeometricAveragePriceAsianEnginePtr(
                new AnalyticContinuousGeometricAveragePriceAsianEngine(
                                                                  bsProcess));
        }

using QuantLib::AnalyticDiscreteGeometricAveragePriceAsianEngine;
typedef boost::shared_ptr<PricingEngine>
    AnalyticDiscreteGeometricAveragePriceAsianEnginePtr;

SWIGINTERN AnalyticDiscreteGeometricAveragePriceAsianEnginePtr *new_AnalyticDiscreteGeometricAveragePriceAsianEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticDiscreteGeometricAveragePriceAsianEnginePtr(
                new AnalyticDiscreteGeometricAveragePriceAsianEngine(
                                                                  bsProcess));
        }

using QuantLib::AnalyticDiscreteGeometricAverageStrikeAsianEngine;
typedef boost::shared_ptr<PricingEngine>
    AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr;

SWIGINTERN AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr *new_AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr(
                new AnalyticDiscreteGeometricAverageStrikeAsianEngine(
                                                                  bsProcess));
        }

using QuantLib::MCDiscreteArithmeticAPEngine;
typedef boost::shared_ptr<PricingEngine> MCDiscreteArithmeticAPEnginePtr;

SWIGINTERN MCDiscreteArithmeticAPEnginePtr *new_MCDiscreteArithmeticAPEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,std::string const &traits,bool brownianBridge=false,bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            if (s == "pseudorandom" || s == "pr")
                return new MCDiscreteArithmeticAPEnginePtr(
                         new MCDiscreteArithmeticAPEngine<PseudoRandom>(
                                                            bsProcess,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            controlVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCDiscreteArithmeticAPEnginePtr(
                       new MCDiscreteArithmeticAPEngine<LowDiscrepancy>(
                                                            bsProcess,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            controlVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::MCDiscreteArithmeticASEngine;
typedef boost::shared_ptr<PricingEngine> MCDiscreteArithmeticASEnginePtr;

SWIGINTERN MCDiscreteArithmeticASEnginePtr *new_MCDiscreteArithmeticASEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,std::string const &traits,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            if (s == "pseudorandom" || s == "pr")
                return new MCDiscreteArithmeticASEnginePtr(
                         new MCDiscreteArithmeticASEngine<PseudoRandom>(
                                                            bsProcess,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCDiscreteArithmeticASEnginePtr(
                       new MCDiscreteArithmeticASEngine<LowDiscrepancy>(
                                                            bsProcess,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::MCDiscreteGeometricAPEngine;
typedef boost::shared_ptr<PricingEngine> MCDiscreteGeometricAPEnginePtr;

SWIGINTERN MCDiscreteGeometricAPEnginePtr *new_MCDiscreteGeometricAPEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,std::string const &traits,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            if (s == "pseudorandom" || s == "pr")
                return new MCDiscreteGeometricAPEnginePtr(
                         new MCDiscreteGeometricAPEngine<PseudoRandom>(
                                                            bsProcess,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCDiscreteGeometricAPEnginePtr(
                       new MCDiscreteGeometricAPEngine<LowDiscrepancy>(
                                                            bsProcess,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::VarianceGammaEngine;
typedef boost::shared_ptr<PricingEngine>
    VarianceGammaEnginePtr;

SWIGINTERN VarianceGammaEnginePtr *new_VarianceGammaEnginePtr(VarianceGammaProcessPtr const &process){
            boost::shared_ptr<VarianceGammaProcess> vgProcess =
                boost::dynamic_pointer_cast<VarianceGammaProcess>(process);
            QL_REQUIRE(vgProcess, "Variance-Gamma process required");
            return new VarianceGammaEnginePtr(new VarianceGammaEngine(vgProcess));
        }

using QuantLib::FFTVarianceGammaEngine;
typedef boost::shared_ptr<PricingEngine>
    FFTVarianceGammaEnginePtr;

SWIGINTERN FFTVarianceGammaEnginePtr *new_FFTVarianceGammaEnginePtr__SWIG_0(VarianceGammaProcessPtr const &process,Real logStrikeSpacing=0.001){
            boost::shared_ptr<VarianceGammaProcess> vgProcess =
                boost::dynamic_pointer_cast<VarianceGammaProcess>(process);
            QL_REQUIRE(vgProcess, "Variance Gamma process required");
            return new FFTVarianceGammaEnginePtr(new FFTVarianceGammaEngine(vgProcess, logStrikeSpacing));
        }
SWIGINTERN void FFTVarianceGammaEnginePtr_precalculate(FFTVarianceGammaEnginePtr *self,std::vector< boost::shared_ptr< Instrument > > const &optionList){
            boost::dynamic_pointer_cast<FFTVarianceGammaEngine>(*self)->precalculate(optionList);
        }

using QuantLib::DoubleBarrierOption;
using QuantLib::DoubleBarrier;


using QuantLib::DoubleBarrierOption;
typedef boost::shared_ptr<Instrument> DoubleBarrierOptionPtr;

SWIGINTERN DoubleBarrierOptionPtr *new_DoubleBarrierOptionPtr(DoubleBarrier::Type barrierType,Real barrier_lo,Real barrier_hi,Real rebate,boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new DoubleBarrierOptionPtr(
                               new DoubleBarrierOption(barrierType, barrier_lo, 
                                                 barrier_hi, rebate,
                                                 stPayoff,exercise));
        }
SWIGINTERN Real DoubleBarrierOptionPtr_delta(DoubleBarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<DoubleBarrierOption>(*self)->delta();
    }
SWIGINTERN Real DoubleBarrierOptionPtr_gamma(DoubleBarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<DoubleBarrierOption>(*self)->gamma();
    }
SWIGINTERN Real DoubleBarrierOptionPtr_theta(DoubleBarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<DoubleBarrierOption>(*self)->theta();
    }
SWIGINTERN Real DoubleBarrierOptionPtr_thetaPerDay(DoubleBarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<DoubleBarrierOption>(*self)->thetaPerDay();
    }
SWIGINTERN Real DoubleBarrierOptionPtr_vega(DoubleBarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<DoubleBarrierOption>(*self)->vega();
    }
SWIGINTERN Real DoubleBarrierOptionPtr_rho(DoubleBarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<DoubleBarrierOption>(*self)->rho();
    }
SWIGINTERN Real DoubleBarrierOptionPtr_dividendRho(DoubleBarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<DoubleBarrierOption>(*self)->dividendRho();
    }
SWIGINTERN Real DoubleBarrierOptionPtr_strikeSensitivity(DoubleBarrierOptionPtr *self){
        return boost::dynamic_pointer_cast<DoubleBarrierOption>(*self)->strikeSensitivity();
    }

using QuantLib::QuantoDoubleBarrierOption;
typedef boost::shared_ptr<Instrument> QuantoDoubleBarrierOptionPtr;

SWIGINTERN QuantoDoubleBarrierOptionPtr *new_QuantoDoubleBarrierOptionPtr(DoubleBarrier::Type barrierType,Real barrier_lo,Real barrier_hi,Real rebate,boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<StrikedTypePayoff> stPayoff =
                 boost::dynamic_pointer_cast<StrikedTypePayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new QuantoDoubleBarrierOptionPtr(
                         new QuantoDoubleBarrierOption(barrierType, barrier_lo, 
                                      barrier_hi, rebate, stPayoff, exercise));
        }
SWIGINTERN Real QuantoDoubleBarrierOptionPtr_qvega(QuantoDoubleBarrierOptionPtr *self){
            return boost::dynamic_pointer_cast<QuantoDoubleBarrierOption>(*self)
                ->qvega();
        }
SWIGINTERN Real QuantoDoubleBarrierOptionPtr_qrho(QuantoDoubleBarrierOptionPtr *self){
            return boost::dynamic_pointer_cast<QuantoDoubleBarrierOption>(*self)
                ->qrho();
        }
SWIGINTERN Real QuantoDoubleBarrierOptionPtr_qlambda(QuantoDoubleBarrierOptionPtr *self){
            return boost::dynamic_pointer_cast<QuantoDoubleBarrierOption>(*self)
                ->qlambda();
        }

using QuantLib::AnalyticDoubleBarrierEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticDoubleBarrierEnginePtr;

SWIGINTERN AnalyticDoubleBarrierEnginePtr *new_AnalyticDoubleBarrierEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,int series=5){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticDoubleBarrierEnginePtr(
                            new AnalyticDoubleBarrierEngine(bsProcess, series));
        }

using QuantLib::WulinYongDoubleBarrierEngine;
typedef boost::shared_ptr<PricingEngine> WulinYongDoubleBarrierEnginePtr;

SWIGINTERN WulinYongDoubleBarrierEnginePtr *new_WulinYongDoubleBarrierEnginePtr__SWIG_0(GeneralizedBlackScholesProcessPtr const &process,int series=5){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new WulinYongDoubleBarrierEnginePtr(
                            new WulinYongDoubleBarrierEngine(bsProcess, series));
        }

using QuantLib::VannaVolgaDoubleBarrierEngine;
using QuantLib::DeltaVolQuote;
typedef boost::shared_ptr<PricingEngine> VannaVolgaDoubleBarrierEnginePtr;

SWIGINTERN bool boost_shared_ptr_Sl_DeltaVolQuote_Sg__isNull(boost::shared_ptr< DeltaVolQuote > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_DeltaVolQuote_Sg__asObservable(boost::shared_ptr< DeltaVolQuote > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< DeltaVolQuote > *new_boost_shared_ptr_Sl_DeltaVolQuote_Sg___SWIG_0(Real delta,Handle< Quote > const &vol,Time maturity,DeltaVolQuote::DeltaType deltaType){
        return new boost::shared_ptr<DeltaVolQuote>(
                          new DeltaVolQuote(delta, vol, maturity, deltaType));
    }
SWIGINTERN boost::shared_ptr< DeltaVolQuote > *new_boost_shared_ptr_Sl_DeltaVolQuote_Sg___SWIG_1(Handle< Quote > const &vol,DeltaVolQuote::DeltaType deltaType,Time maturity,DeltaVolQuote::AtmType atmType){
        return new boost::shared_ptr<DeltaVolQuote>(
                        new DeltaVolQuote(vol, deltaType, maturity, atmType));
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_DeltaVolQuote_Sg__asObservable(Handle< DeltaVolQuote > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN VannaVolgaDoubleBarrierEnginePtr *new_VannaVolgaDoubleBarrierEnginePtr__SWIG_0(Handle< DeltaVolQuote > const atmVol,Handle< DeltaVolQuote > const vol25Put,Handle< DeltaVolQuote > const vol25Call,Handle< Quote > const spotFX,Handle< YieldTermStructure > const domesticTS,Handle< YieldTermStructure > const foreignTS,std::string const &type="ik",bool const adaptVanDelta=false,Real const bsPriceWithSmile=0.0,int series=5){
            std::string s = boost::algorithm::to_lower_copy(type);
            if (s == "ik" || s == "analytic")
                return new VannaVolgaDoubleBarrierEnginePtr(
                   new VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine>(
                                        atmVol, vol25Put, vol25Call, spotFX, 
                                        domesticTS, foreignTS, adaptVanDelta, 
                                        bsPriceWithSmile, series));
            else if (s == "wo")
                return new VannaVolgaDoubleBarrierEnginePtr(
                   new VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine>(
                                        atmVol, vol25Put, vol25Call, spotFX, 
                                        domesticTS, foreignTS, adaptVanDelta, 
                                        bsPriceWithSmile, series));
            else
                QL_FAIL("unknown binomial engine type: "+s);
        }

using QuantLib::AnalyticDoubleBarrierBinaryEngine;
typedef boost::shared_ptr<PricingEngine> AnalyticDoubleBarrierBinaryEnginePtr;

SWIGINTERN AnalyticDoubleBarrierBinaryEnginePtr *new_AnalyticDoubleBarrierBinaryEnginePtr(GeneralizedBlackScholesProcessPtr const &process){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            return new AnalyticDoubleBarrierBinaryEnginePtr(
                            new AnalyticDoubleBarrierBinaryEngine(bsProcess));
        }

using QuantLib::BinomialDoubleBarrierEngine;
using QuantLib::DiscretizedDermanKaniDoubleBarrierOption;
typedef boost::shared_ptr<PricingEngine> BinomialDoubleBarrierEnginePtr;

SWIGINTERN BinomialDoubleBarrierEnginePtr *new_BinomialDoubleBarrierEnginePtr(GeneralizedBlackScholesProcessPtr const &process,std::string const &type,Size steps){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(type);
            if (s == "crr" || s == "coxrossrubinstein")
                return new BinomialDoubleBarrierEnginePtr(
                    new BinomialDoubleBarrierEngine<CoxRossRubinstein,
                                     DiscretizedDermanKaniDoubleBarrierOption>(
                                                  bsProcess,steps));
            else if (s == "jr" || s == "jarrowrudd")
                return new BinomialDoubleBarrierEnginePtr(
                    new BinomialDoubleBarrierEngine<JarrowRudd,
                                     DiscretizedDermanKaniDoubleBarrierOption>(
                                                  bsProcess,steps));
            else if (s == "eqp" || s == "additiveeqpbinomialtree")
                return new BinomialDoubleBarrierEnginePtr(
                    new BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,
                                     DiscretizedDermanKaniDoubleBarrierOption>(
                                                  bsProcess,steps));
            else if (s == "trigeorgis")
                return new BinomialDoubleBarrierEnginePtr(
                    new BinomialDoubleBarrierEngine<Trigeorgis,
                                     DiscretizedDermanKaniDoubleBarrierOption>(
                                                  bsProcess,steps));
            else if (s == "tian")
                return new BinomialDoubleBarrierEnginePtr(
                    new BinomialDoubleBarrierEngine<Tian,
                                     DiscretizedDermanKaniDoubleBarrierOption>(
                                                  bsProcess,steps));
            else if (s == "lr" || s == "leisenreimer")
                return new BinomialDoubleBarrierEnginePtr(
                    new BinomialDoubleBarrierEngine<LeisenReimer,
                                     DiscretizedDermanKaniDoubleBarrierOption>(
                                                  bsProcess,steps));
            else if (s == "j4" || s == "joshi4")
                return new BinomialDoubleBarrierEnginePtr(
                    new BinomialDoubleBarrierEngine<Joshi4,
                                     DiscretizedDermanKaniDoubleBarrierOption>(
                                                  bsProcess,steps));
            else
                QL_FAIL("unknown binomial double barrier engine type: "+s);
        }

using QuantLib::PlainVanillaPayoff;
using QuantLib::PercentageStrikePayoff;
using QuantLib::CashOrNothingPayoff;
using QuantLib::AssetOrNothingPayoff;
using QuantLib::SuperSharePayoff;
using QuantLib::GapPayoff;
typedef boost::shared_ptr<Payoff> PlainVanillaPayoffPtr;
typedef boost::shared_ptr<Payoff> PercentageStrikePayoffPtr;
typedef boost::shared_ptr<Payoff> CashOrNothingPayoffPtr;
typedef boost::shared_ptr<Payoff> AssetOrNothingPayoffPtr;
typedef boost::shared_ptr<Payoff> SuperSharePayoffPtr;
typedef boost::shared_ptr<Payoff> GapPayoffPtr;

SWIGINTERN PlainVanillaPayoffPtr *new_PlainVanillaPayoffPtr(Option::Type type,Real strike){
            return new PlainVanillaPayoffPtr(
                                        new PlainVanillaPayoff(type, strike));
        }
SWIGINTERN Option::Type PlainVanillaPayoffPtr_optionType(PlainVanillaPayoffPtr *self){
          	return boost::dynamic_pointer_cast<
									PlainVanillaPayoff>(*self)->optionType();
		}
SWIGINTERN Real PlainVanillaPayoffPtr_strike(PlainVanillaPayoffPtr *self){
          	return boost::dynamic_pointer_cast<
									PlainVanillaPayoff>(*self)->strike();
		}
SWIGINTERN PercentageStrikePayoffPtr *new_PercentageStrikePayoffPtr(Option::Type type,Real moneyness){
            return new PercentageStrikePayoffPtr(
                                 new PercentageStrikePayoff(type, moneyness));
        }
SWIGINTERN CashOrNothingPayoffPtr *new_CashOrNothingPayoffPtr(Option::Type type,Real strike,Real payoff){
            return new CashOrNothingPayoffPtr(
                               new CashOrNothingPayoff(type, strike, payoff));
        }
SWIGINTERN AssetOrNothingPayoffPtr *new_AssetOrNothingPayoffPtr(Option::Type type,Real strike){
            return new AssetOrNothingPayoffPtr(
                                      new AssetOrNothingPayoff(type, strike));
        }
SWIGINTERN SuperSharePayoffPtr *new_SuperSharePayoffPtr(Option::Type type,Real strike,Real increment){
            return new SuperSharePayoffPtr(
                               new SuperSharePayoff(type, strike, increment));
        }
SWIGINTERN GapPayoffPtr *new_GapPayoffPtr(Option::Type type,Real strike,Real strikePayoff){
            return new GapPayoffPtr(
                               new GapPayoff(type, strike, strikePayoff));
        }

using QuantLib::BasketOption;
using QuantLib::BasketPayoff;
using QuantLib::MinBasketPayoff;
using QuantLib::MaxBasketPayoff;
using QuantLib::AverageBasketPayoff;
typedef boost::shared_ptr<Instrument> BasketOptionPtr;
typedef boost::shared_ptr<Payoff> BasketPayoffPtr;
typedef boost::shared_ptr<Payoff> MinBasketPayoffPtr;
typedef boost::shared_ptr<Payoff> MaxBasketPayoffPtr;
typedef boost::shared_ptr<Payoff> AverageBasketPayoffPtr;

SWIGINTERN MinBasketPayoffPtr *new_MinBasketPayoffPtr(boost::shared_ptr< Payoff > const p){
            return new MinBasketPayoffPtr(new MinBasketPayoff(p));
        }
SWIGINTERN MaxBasketPayoffPtr *new_MaxBasketPayoffPtr(boost::shared_ptr< Payoff > const p){
            return new MaxBasketPayoffPtr(new MaxBasketPayoff(p));
        }
SWIGINTERN AverageBasketPayoffPtr *new_AverageBasketPayoffPtr__SWIG_0(boost::shared_ptr< Payoff > const p,Array const &a){
            return new AverageBasketPayoffPtr(new AverageBasketPayoff(p, a));
        }
SWIGINTERN AverageBasketPayoffPtr *new_AverageBasketPayoffPtr__SWIG_1(boost::shared_ptr< Payoff > const p,Size n){
            return new AverageBasketPayoffPtr(new AverageBasketPayoff(p, n));
        }
SWIGINTERN BasketOptionPtr *new_BasketOptionPtr(boost::shared_ptr< Payoff > const &payoff,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<BasketPayoff> stPayoff =
                 boost::dynamic_pointer_cast<BasketPayoff>(payoff);
            QL_REQUIRE(stPayoff, "wrong payoff given");
            return new BasketOptionPtr(new BasketOption(stPayoff,exercise));
        }

using QuantLib::MCEuropeanBasketEngine;
typedef boost::shared_ptr<PricingEngine> MCEuropeanBasketEnginePtr;

SWIGINTERN MCEuropeanBasketEnginePtr *new_MCEuropeanBasketEnginePtr__SWIG_0(StochasticProcessArrayPtr const &process,std::string const &traits,Size timeSteps=Null< Size >(),Size timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            boost::shared_ptr<StochasticProcessArray> processes =
                 boost::dynamic_pointer_cast<StochasticProcessArray>(process);
            QL_REQUIRE(processes, "stochastic-process array required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            if (s == "pseudorandom" || s == "pr")
                return new MCEuropeanBasketEnginePtr(
                   new MCEuropeanBasketEngine<PseudoRandom>(processes,
                                                            timeSteps,
                                                            timeStepsPerYear,
                                                            brownianBridge,
                                                            antitheticVariate,
                                                            requiredSamples,
                                                            requiredTolerance,
                                                            maxSamples,
                                                            seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCEuropeanBasketEnginePtr(
                   new MCEuropeanBasketEngine<LowDiscrepancy>(processes,
                                                              timeSteps,
                                                              timeStepsPerYear,
                                                              brownianBridge,
                                                              antitheticVariate,
                                                              requiredSamples,
                                                              requiredTolerance,
                                                              maxSamples,
                                                              seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::MCAmericanBasketEngine;
typedef boost::shared_ptr<PricingEngine> MCAmericanBasketEnginePtr;

SWIGINTERN MCAmericanBasketEnginePtr *new_MCAmericanBasketEnginePtr__SWIG_0(StochasticProcessArrayPtr const &process,std::string const &traits,Size timeSteps=Null< Size >(),Size timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            boost::shared_ptr<StochasticProcessArray> processes =
                 boost::dynamic_pointer_cast<StochasticProcessArray>(process);
            QL_REQUIRE(processes, "stochastic-process array required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            if (s == "pseudorandom" || s == "pr")
                  return new MCAmericanBasketEnginePtr(
                  new MCAmericanBasketEngine<PseudoRandom>(processes,
                                                           timeSteps,
                                                           timeStepsPerYear,
                                                           brownianBridge,
                                                           antitheticVariate,
                                                           requiredSamples,
                                                           requiredTolerance,
                                                           maxSamples,
                                                           seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCAmericanBasketEnginePtr(
                new MCAmericanBasketEngine<LowDiscrepancy>(processes,
                                                           timeSteps,
                                                           timeStepsPerYear,
                                                           brownianBridge,
                                                           antitheticVariate,
                                                           requiredSamples,
                                                           requiredTolerance,
                                                           maxSamples,
                                                           seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::StulzEngine;
typedef boost::shared_ptr<PricingEngine> StulzEnginePtr;

SWIGINTERN StulzEnginePtr *new_StulzEnginePtr(GeneralizedBlackScholesProcessPtr const &process1,GeneralizedBlackScholesProcessPtr const &process2,Real correlation){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess1 =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                    process1);
            QL_REQUIRE(bsProcess1, "Black-Scholes process required");
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess2 =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                    process2);
            QL_REQUIRE(bsProcess2, "Black-Scholes process required");
            return new StulzEnginePtr(
                          new StulzEngine(bsProcess1,bsProcess2,correlation));
        }

using QuantLib::EverestOption;
typedef boost::shared_ptr<Instrument> EverestOptionPtr;
using QuantLib::MCEverestEngine;
typedef boost::shared_ptr<PricingEngine> MCEverestEnginePtr;

SWIGINTERN EverestOptionPtr *new_EverestOptionPtr(Real notional,Rate guarantee,boost::shared_ptr< Exercise > const &exercise){
            return new EverestOptionPtr(new EverestOption(notional,guarantee,
                                                          exercise));
        }
SWIGINTERN MCEverestEnginePtr *new_MCEverestEnginePtr__SWIG_0(StochasticProcessArrayPtr const &process,std::string const &traits,Size timeSteps=Null< Size >(),Size timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            boost::shared_ptr<StochasticProcessArray> processes =
                 boost::dynamic_pointer_cast<StochasticProcessArray>(process);
            QL_REQUIRE(processes, "stochastic-process array required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            if (s == "pseudorandom" || s == "pr")
                return new MCEverestEnginePtr(
                        new MCEverestEngine<PseudoRandom>(processes,
                                                          timeSteps,
                                                          timeStepsPerYear,
                                                          brownianBridge,
                                                          antitheticVariate,
                                                          requiredSamples,
                                                          requiredTolerance,
                                                          maxSamples,
                                                          seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCEverestEnginePtr(
                      new MCEverestEngine<LowDiscrepancy>(processes,
                                                          timeSteps,
                                                          timeStepsPerYear,
                                                          brownianBridge,
                                                          antitheticVariate,
                                                          requiredSamples,
                                                          requiredTolerance,
                                                          maxSamples,
                                                          seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::HimalayaOption;
typedef boost::shared_ptr<Instrument> HimalayaOptionPtr;
using QuantLib::MCHimalayaEngine;
typedef boost::shared_ptr<PricingEngine> MCHimalayaEnginePtr;

SWIGINTERN HimalayaOptionPtr *new_HimalayaOptionPtr(std::vector< Date > const &fixingDates,Real strike){
            return new HimalayaOptionPtr(new HimalayaOption(fixingDates,
                                                            strike));
        }
SWIGINTERN MCHimalayaEnginePtr *new_MCHimalayaEnginePtr__SWIG_0(StochasticProcessArrayPtr const &process,std::string const &traits,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            boost::shared_ptr<StochasticProcessArray> processes =
                 boost::dynamic_pointer_cast<StochasticProcessArray>(process);
            QL_REQUIRE(processes, "stochastic-process array required");
            std::string s = boost::algorithm::to_lower_copy(traits);
            if (s == "pseudorandom" || s == "pr")
                return new MCHimalayaEnginePtr(
                       new MCHimalayaEngine<PseudoRandom>(processes,
                                                          brownianBridge,
                                                          antitheticVariate,
                                                          requiredSamples,
                                                          requiredTolerance,
                                                          maxSamples,
                                                          seed));
            else if (s == "lowdiscrepancy" || s == "ld")
                return new MCHimalayaEnginePtr(
                     new MCHimalayaEngine<LowDiscrepancy>(processes,
                                                          brownianBridge,
                                                          antitheticVariate,
                                                          requiredSamples,
                                                          requiredTolerance,
                                                          maxSamples,
                                                          seed));
            else
                QL_FAIL("unknown Monte Carlo engine type: "+s);
        }

using QuantLib::blackFormula;
using QuantLib::blackFormulaImpliedStdDev;
using QuantLib::blackFormulaCashItmProbability;
using QuantLib::bachelierBlackFormula;
using QuantLib::bachelierBlackFormulaImpliedVol;


using QuantLib::BlackDeltaCalculator;


using QuantLib::Callability;
using QuantLib::SoftCallability;
typedef boost::shared_ptr<Callability> CallabilityPtr;
typedef boost::shared_ptr<Callability> SoftCallabilityPtr;
typedef Callability::Price CallabilityPrice;
using QuantLib::CallabilitySchedule;

SWIGINTERN bool boost_shared_ptr_Sl_Callability_Sg__isNull(boost::shared_ptr< Callability > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Callability > *new_boost_shared_ptr_Sl_Callability_Sg_(CallabilityPrice const &price,Callability::Type type,Date const &date){
        return new boost::shared_ptr<Callability>(
                                            new Callability(price,type,date));
    }

using QuantLib::SoftCallability;
typedef boost::shared_ptr<Callability> SoftCallabilityPtr;

SWIGINTERN SoftCallabilityPtr *new_SoftCallabilityPtr(CallabilityPrice const &price,Date const &date,Real trigger){
            return new SoftCallabilityPtr(new SoftCallability(price,date,
                                                              trigger));
        }
SWIGINTERN std::vector< boost::shared_ptr< Callability > > *new_std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<Callability> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<Callability> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< Callability > std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< Callability > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< Callability > const &std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__getitem(std::vector< boost::shared_ptr< Callability > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__setitem(std::vector< boost::shared_ptr< Callability > > *self,int index,boost::shared_ptr< Callability > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__AddRange(std::vector< boost::shared_ptr< Callability > > *self,std::vector< boost::shared_ptr< Callability > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< Callability > > *std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__GetRange(std::vector< boost::shared_ptr< Callability > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<Callability> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Insert(std::vector< boost::shared_ptr< Callability > > *self,int index,boost::shared_ptr< Callability > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< Callability > > *self,int index,std::vector< boost::shared_ptr< Callability > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< Callability > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< Callability > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< Callability > > *std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Repeat(boost::shared_ptr< Callability > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<Callability> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< Callability > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< Callability > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__SetRange(std::vector< boost::shared_ptr< Callability > > *self,int index,std::vector< boost::shared_ptr< Callability > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Contains(std::vector< boost::shared_ptr< Callability > > *self,boost::shared_ptr< Callability > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< Callability > > *self,boost::shared_ptr< Callability > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<Callability> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< Callability > > *self,boost::shared_ptr< Callability > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<Callability> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Remove(std::vector< boost::shared_ptr< Callability > > *self,boost::shared_ptr< Callability > const &value){
        std::vector< boost::shared_ptr<Callability> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

  using QuantLib::Seasonality;
  using QuantLib::MultiplicativePriceSeasonality;
  typedef boost::shared_ptr<Seasonality> MultiplicativePriceSeasonalityPtr;

SWIGINTERN bool boost_shared_ptr_Sl_Seasonality_Sg__isNull(boost::shared_ptr< Seasonality > *self){
                return !(*self);
            }
SWIGINTERN MultiplicativePriceSeasonalityPtr *new_MultiplicativePriceSeasonalityPtr(Date const &seasonalityBaseDate,Frequency frequency,std::vector< Rate > const &seasonalityFactors){
            return new MultiplicativePriceSeasonalityPtr(
                       new MultiplicativePriceSeasonality(seasonalityBaseDate,
                                                          frequency,
                                                          seasonalityFactors));
        }

  using QuantLib::InflationTermStructure;
  using QuantLib::YoYInflationTermStructure;
  using QuantLib::ZeroInflationTermStructure;

SWIGINTERN bool boost_shared_ptr_Sl_YoYInflationTermStructure_Sg__isNull(boost::shared_ptr< YoYInflationTermStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_YoYInflationTermStructure_Sg__asObservable(boost::shared_ptr< YoYInflationTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_YoYInflationTermStructure_Sg__asObservable(Handle< YoYInflationTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN bool boost_shared_ptr_Sl_ZeroInflationTermStructure_Sg__isNull(boost::shared_ptr< ZeroInflationTermStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_ZeroInflationTermStructure_Sg__asObservable(boost::shared_ptr< ZeroInflationTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_ZeroInflationTermStructure_Sg__asObservable(Handle< ZeroInflationTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }

#include <ql/indexes/inflationindex.hpp>
#include <ql/indexes/inflation/all.hpp>
using QuantLib::Region;
using QuantLib::CustomRegion;
using QuantLib::InflationIndex;
using QuantLib::ZeroInflationIndex;
using QuantLib::YoYInflationIndex;
typedef boost::shared_ptr<Index> InflationIndexPtr;
typedef boost::shared_ptr<Index> ZeroInflationIndexPtr;
typedef boost::shared_ptr<Index> YoYInflationIndexPtr;

SWIGINTERN bool InflationIndexPtr_interpolated(InflationIndexPtr const *self){
            return boost::dynamic_pointer_cast<InflationIndex>(*self)
                ->interpolated();
        }
SWIGINTERN Frequency InflationIndexPtr_frequency(InflationIndexPtr const *self){
            return boost::dynamic_pointer_cast<InflationIndex>(*self)
                ->frequency();
        }
SWIGINTERN Period InflationIndexPtr_availabilityLag(InflationIndexPtr const *self){
            return boost::dynamic_pointer_cast<InflationIndex>(*self)
                ->availabilityLag();
        }
SWIGINTERN Currency InflationIndexPtr_currency(InflationIndexPtr const *self){
            return boost::dynamic_pointer_cast<InflationIndex>(*self)
                ->currency();
        }
SWIGINTERN ZeroInflationIndexPtr *new_ZeroInflationIndexPtr__SWIG_0(std::string const &familyName,Region const &region,bool revised,bool interpolated,Frequency frequency,Period const &availabilityLag,Currency const &currency,Handle< ZeroInflationTermStructure > const &h=Handle< ZeroInflationTermStructure >()){
          return new ZeroInflationIndexPtr(
              new ZeroInflationIndex(familyName, region, revised, interpolated,
                                     frequency, availabilityLag, currency, h));
      }

using QuantLib::EUHICP;
typedef boost::shared_ptr<Index> EUHICPPtr;

SWIGINTERN EUHICPPtr *new_EUHICPPtr__SWIG_0(bool interpolated,Handle< ZeroInflationTermStructure > const &h=Handle< ZeroInflationTermStructure >()){
          return new EUHICPPtr(new EUHICP(interpolated,h));
      }

using QuantLib::EUHICPXT;
typedef boost::shared_ptr<Index> EUHICPXTPtr;

SWIGINTERN EUHICPXTPtr *new_EUHICPXTPtr__SWIG_0(bool interpolated,Handle< ZeroInflationTermStructure > const &h=Handle< ZeroInflationTermStructure >()){
          return new EUHICPXTPtr(new EUHICPXT(interpolated,h));
      }

using QuantLib::FRHICP;
typedef boost::shared_ptr<Index> FRHICPPtr;

SWIGINTERN FRHICPPtr *new_FRHICPPtr__SWIG_0(bool interpolated,Handle< ZeroInflationTermStructure > const &h=Handle< ZeroInflationTermStructure >()){
          return new FRHICPPtr(new FRHICP(interpolated,h));
      }

using QuantLib::UKRPI;
typedef boost::shared_ptr<Index> UKRPIPtr;

SWIGINTERN UKRPIPtr *new_UKRPIPtr__SWIG_0(bool interpolated,Handle< ZeroInflationTermStructure > const &h=Handle< ZeroInflationTermStructure >()){
          return new UKRPIPtr(new UKRPI(interpolated,h));
      }

using QuantLib::USCPI;
typedef boost::shared_ptr<Index> USCPIPtr;

SWIGINTERN USCPIPtr *new_USCPIPtr__SWIG_0(bool interpolated,Handle< ZeroInflationTermStructure > const &h=Handle< ZeroInflationTermStructure >()){
          return new USCPIPtr(new USCPI(interpolated,h));
      }

using QuantLib::ZACPI;
typedef boost::shared_ptr<Index> ZACPIPtr;

SWIGINTERN ZACPIPtr *new_ZACPIPtr__SWIG_0(bool interpolated,Handle< ZeroInflationTermStructure > const &h=Handle< ZeroInflationTermStructure >()){
          return new ZACPIPtr(new ZACPI(interpolated,h));
      }

using QuantLib::YYEUHICP;
typedef boost::shared_ptr<Index> YYEUHICPPtr;

SWIGINTERN YYEUHICPPtr *new_YYEUHICPPtr__SWIG_0(bool interpolated,Handle< YoYInflationTermStructure > const &h=Handle< YoYInflationTermStructure >()){
          return new YYEUHICPPtr(new YYEUHICP(interpolated,h));
      }

using QuantLib::YYEUHICPXT;
typedef boost::shared_ptr<Index> YYEUHICPXTPtr;

SWIGINTERN YYEUHICPXTPtr *new_YYEUHICPXTPtr__SWIG_0(bool interpolated,Handle< YoYInflationTermStructure > const &h=Handle< YoYInflationTermStructure >()){
          return new YYEUHICPXTPtr(new YYEUHICPXT(interpolated,h));
      }

using QuantLib::YYFRHICP;
typedef boost::shared_ptr<Index> YYFRHICPPtr;

SWIGINTERN YYFRHICPPtr *new_YYFRHICPPtr__SWIG_0(bool interpolated,Handle< YoYInflationTermStructure > const &h=Handle< YoYInflationTermStructure >()){
          return new YYFRHICPPtr(new YYFRHICP(interpolated,h));
      }

using QuantLib::YYUKRPI;
typedef boost::shared_ptr<Index> YYUKRPIPtr;

SWIGINTERN YYUKRPIPtr *new_YYUKRPIPtr__SWIG_0(bool interpolated,Handle< YoYInflationTermStructure > const &h=Handle< YoYInflationTermStructure >()){
          return new YYUKRPIPtr(new YYUKRPI(interpolated,h));
      }

using QuantLib::YYUSCPI;
typedef boost::shared_ptr<Index> YYUSCPIPtr;

SWIGINTERN YYUSCPIPtr *new_YYUSCPIPtr__SWIG_0(bool interpolated,Handle< YoYInflationTermStructure > const &h=Handle< YoYInflationTermStructure >()){
          return new YYUSCPIPtr(new YYUSCPI(interpolated,h));
      }

using QuantLib::YYZACPI;
typedef boost::shared_ptr<Index> YYZACPIPtr;

SWIGINTERN YYZACPIPtr *new_YYZACPIPtr__SWIG_0(bool interpolated,Handle< YoYInflationTermStructure > const &h=Handle< YoYInflationTermStructure >()){
          return new YYZACPIPtr(new YYZACPI(interpolated,h));
      }

    using QuantLib::CPI;


typedef QuantLib::BootstrapHelper<ZeroInflationTermStructure> ZeroHelper;
typedef QuantLib::BootstrapHelper<YoYInflationTermStructure> YoYHelper;

using QuantLib::ZeroCouponInflationSwapHelper;
typedef boost::shared_ptr<ZeroHelper> ZeroCouponInflationSwapHelperPtr;

using QuantLib::YearOnYearInflationSwapHelper;
typedef boost::shared_ptr<YoYHelper> YearOnYearInflationSwapHelperPtr;

SWIGINTERN bool boost_shared_ptr_Sl_ZeroHelper_Sg__isNull(boost::shared_ptr< ZeroHelper > *self){
                return !(*self);
            }
SWIGINTERN bool boost_shared_ptr_Sl_YoYHelper_Sg__isNull(boost::shared_ptr< YoYHelper > *self){
                return !(*self);
            }
SWIGINTERN std::vector< boost::shared_ptr< ZeroHelper > > *new_std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<ZeroHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<ZeroHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< ZeroHelper > std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< ZeroHelper > const &std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__getitem(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__setitem(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index,boost::shared_ptr< ZeroHelper > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__AddRange(std::vector< boost::shared_ptr< ZeroHelper > > *self,std::vector< boost::shared_ptr< ZeroHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< ZeroHelper > > *std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__GetRange(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<ZeroHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Insert(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index,boost::shared_ptr< ZeroHelper > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index,std::vector< boost::shared_ptr< ZeroHelper > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< ZeroHelper > > *std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Repeat(boost::shared_ptr< ZeroHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<ZeroHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< ZeroHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__SetRange(std::vector< boost::shared_ptr< ZeroHelper > > *self,int index,std::vector< boost::shared_ptr< ZeroHelper > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Contains(std::vector< boost::shared_ptr< ZeroHelper > > *self,boost::shared_ptr< ZeroHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< ZeroHelper > > *self,boost::shared_ptr< ZeroHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<ZeroHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< ZeroHelper > > *self,boost::shared_ptr< ZeroHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<ZeroHelper> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Remove(std::vector< boost::shared_ptr< ZeroHelper > > *self,boost::shared_ptr< ZeroHelper > const &value){
        std::vector< boost::shared_ptr<ZeroHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< boost::shared_ptr< YoYHelper > > *new_std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<YoYHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<YoYHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< YoYHelper > std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< YoYHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< YoYHelper > const &std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__getitem(std::vector< boost::shared_ptr< YoYHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__setitem(std::vector< boost::shared_ptr< YoYHelper > > *self,int index,boost::shared_ptr< YoYHelper > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__AddRange(std::vector< boost::shared_ptr< YoYHelper > > *self,std::vector< boost::shared_ptr< YoYHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< YoYHelper > > *std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__GetRange(std::vector< boost::shared_ptr< YoYHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<YoYHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Insert(std::vector< boost::shared_ptr< YoYHelper > > *self,int index,boost::shared_ptr< YoYHelper > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< YoYHelper > > *self,int index,std::vector< boost::shared_ptr< YoYHelper > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< YoYHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< YoYHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< YoYHelper > > *std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Repeat(boost::shared_ptr< YoYHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<YoYHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< YoYHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< YoYHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__SetRange(std::vector< boost::shared_ptr< YoYHelper > > *self,int index,std::vector< boost::shared_ptr< YoYHelper > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Contains(std::vector< boost::shared_ptr< YoYHelper > > *self,boost::shared_ptr< YoYHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< YoYHelper > > *self,boost::shared_ptr< YoYHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<YoYHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< YoYHelper > > *self,boost::shared_ptr< YoYHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<YoYHelper> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Remove(std::vector< boost::shared_ptr< YoYHelper > > *self,boost::shared_ptr< YoYHelper > const &value){
        std::vector< boost::shared_ptr<YoYHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN ZeroCouponInflationSwapHelperPtr *new_ZeroCouponInflationSwapHelperPtr(Rate rate,Period const &lag,Date const &maturity,Calendar const &calendar,BusinessDayConvention bdc,DayCounter const &dayCounter,ZeroInflationIndexPtr const &index){
            Handle<Quote> quote(
                boost::shared_ptr<Quote>(new SimpleQuote(rate)));
            boost::shared_ptr<ZeroInflationIndex> zeroIndex =
                boost::dynamic_pointer_cast<ZeroInflationIndex>(index);
            return new ZeroCouponInflationSwapHelperPtr(
                new ZeroCouponInflationSwapHelper(quote,lag,maturity,
                                                  calendar,bdc,
                                                  dayCounter,zeroIndex));
        }
SWIGINTERN YearOnYearInflationSwapHelperPtr *new_YearOnYearInflationSwapHelperPtr(Rate rate,Period const &lag,Date const &maturity,Calendar const &calendar,BusinessDayConvention bdc,DayCounter const &dayCounter,YoYInflationIndexPtr const &index){
            Handle<Quote> quote(
                boost::shared_ptr<Quote>(new SimpleQuote(rate)));
            boost::shared_ptr<YoYInflationIndex> yoyIndex =
                boost::dynamic_pointer_cast<YoYInflationIndex>(index);
            return new YearOnYearInflationSwapHelperPtr(
                new YearOnYearInflationSwapHelper(quote,lag,maturity,
                                                  calendar,bdc,
                                                  dayCounter,yoyIndex));
        }

using QuantLib::PiecewiseZeroInflationCurve;
using QuantLib::PiecewiseYoYInflationCurve;


typedef boost::shared_ptr<ZeroInflationTermStructure> PiecewiseZeroInflationPtr;

SWIGINTERN PiecewiseZeroInflationPtr *new_PiecewiseZeroInflationPtr__SWIG_0(Date const &referenceDate,Calendar const &calendar,DayCounter const &dayCounter,Period const &lag,Frequency frequency,bool indexIsInterpolated,Rate baseRate,Handle< YieldTermStructure > const &nominalTS,std::vector< boost::shared_ptr< ZeroHelper > > const &instruments,Real accuracy=1.0e-12,Linear const &i=Linear()){
            return new PiecewiseZeroInflationPtr(
                new PiecewiseZeroInflationCurve<Linear>(
                                        referenceDate, calendar, dayCounter,
                                        lag, frequency, indexIsInterpolated,
                                        baseRate, nominalTS, instruments,
                                        accuracy, i));
        }
SWIGINTERN std::vector< Date > const &PiecewiseZeroInflationPtr_dates(PiecewiseZeroInflationPtr *self){
            typedef PiecewiseZeroInflationCurve<Linear> PiecewiseZeroInflation;
            return boost::dynamic_pointer_cast<PiecewiseZeroInflation>(*self)->dates();
        }
SWIGINTERN std::vector< Time > const &PiecewiseZeroInflationPtr_times(PiecewiseZeroInflationPtr *self){
            typedef PiecewiseZeroInflationCurve<Linear> PiecewiseZeroInflation;
            return boost::dynamic_pointer_cast<PiecewiseZeroInflation>(*self)->times();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > PiecewiseZeroInflationPtr_nodes(PiecewiseZeroInflationPtr *self){
            typedef PiecewiseZeroInflationCurve<Linear> PiecewiseZeroInflation;
            return boost::dynamic_pointer_cast<PiecewiseZeroInflation>(*self)->nodes();
        }

typedef boost::shared_ptr<YoYInflationTermStructure> PiecewiseYoYInflationPtr;

SWIGINTERN PiecewiseYoYInflationPtr *new_PiecewiseYoYInflationPtr__SWIG_0(Date const &referenceDate,Calendar const &calendar,DayCounter const &dayCounter,Period const &lag,Frequency frequency,bool indexIsInterpolated,Rate baseRate,Handle< YieldTermStructure > const &nominalTS,std::vector< boost::shared_ptr< YoYHelper > > const &instruments,Real accuracy=1.0e-12,Linear const &i=Linear()){
            return new PiecewiseYoYInflationPtr(
                new PiecewiseYoYInflationCurve<Linear>(
                                        referenceDate, calendar, dayCounter,
                                        lag, frequency, indexIsInterpolated,
                                        baseRate, nominalTS, instruments,
                                        accuracy, i));
        }
SWIGINTERN std::vector< Date > const &PiecewiseYoYInflationPtr_dates(PiecewiseYoYInflationPtr *self){
            typedef PiecewiseYoYInflationCurve<Linear> PiecewiseYoYInflation;
            return boost::dynamic_pointer_cast<PiecewiseYoYInflation>(*self)->dates();
        }
SWIGINTERN std::vector< Time > const &PiecewiseYoYInflationPtr_times(PiecewiseYoYInflationPtr *self){
            typedef PiecewiseYoYInflationCurve<Linear> PiecewiseYoYInflation;
            return boost::dynamic_pointer_cast<PiecewiseYoYInflation>(*self)->times();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > PiecewiseYoYInflationPtr_nodes(PiecewiseYoYInflationPtr *self){
            typedef PiecewiseYoYInflationCurve<Linear> PiecewiseYoYInflation;
            return boost::dynamic_pointer_cast<PiecewiseYoYInflation>(*self)->nodes();
        }


    Date inflationBaseDate(const Date& referenceDate,
                           const Period& observationLag,
                           Frequency frequency,
                           bool indexIsInterpolated) {
        if (indexIsInterpolated) {
            return referenceDate - observationLag;
        } else {
            return QuantLib::inflationPeriod(referenceDate - observationLag,
                                             frequency).first;
        }
    }



using QuantLib::ZeroCouponInflationSwap;
using QuantLib::YearOnYearInflationSwap;
typedef boost::shared_ptr<Instrument> ZeroCouponInflationSwapPtr;
typedef boost::shared_ptr<Instrument> YearOnYearInflationSwapPtr;

SWIGINTERN ZeroCouponInflationSwapPtr *new_ZeroCouponInflationSwapPtr__SWIG_0(ZeroCouponInflationSwap::Type type,Real nominal,Date const &start,Date const &maturity,Calendar const &calendar,BusinessDayConvention convention,DayCounter const &dayCounter,Rate fixedRate,ZeroInflationIndexPtr const &index,Period const &lag,bool adjustInfObsDates=false,Calendar infCalendar=Calendar(),BusinessDayConvention infConvention=Following){
            boost::shared_ptr<ZeroInflationIndex> zeroIndex =
                boost::dynamic_pointer_cast<ZeroInflationIndex>(index);
            return new ZeroCouponInflationSwapPtr(
                new ZeroCouponInflationSwap(type, nominal, start, maturity,
                                            calendar, convention, dayCounter,
                                            fixedRate, zeroIndex, lag,
                                            adjustInfObsDates,
                                            infCalendar, infConvention));
        }
SWIGINTERN Rate ZeroCouponInflationSwapPtr_fairRate(ZeroCouponInflationSwapPtr *self){
            return boost::dynamic_pointer_cast<ZeroCouponInflationSwap>(*self)
                ->fairRate();
        }
SWIGINTERN std::vector< boost::shared_ptr< CashFlow > > ZeroCouponInflationSwapPtr_fixedLeg(ZeroCouponInflationSwapPtr *self){
            return boost::dynamic_pointer_cast<ZeroCouponInflationSwap>(*self)
                ->fixedLeg();
        }
SWIGINTERN std::vector< boost::shared_ptr< CashFlow > > ZeroCouponInflationSwapPtr_inflationLeg(ZeroCouponInflationSwapPtr *self){
            return boost::dynamic_pointer_cast<ZeroCouponInflationSwap>(*self)
                ->inflationLeg();
        }
SWIGINTERN ZeroCouponInflationSwap::Type ZeroCouponInflationSwapPtr_type(ZeroCouponInflationSwapPtr *self){
            return boost::dynamic_pointer_cast<ZeroCouponInflationSwap>(*self)
                ->type();
        }
SWIGINTERN YearOnYearInflationSwapPtr *new_YearOnYearInflationSwapPtr__SWIG_0(YearOnYearInflationSwap::Type type,Real nominal,Schedule const &fixedSchedule,Rate fixedRate,DayCounter const &fixedDayCounter,Schedule const &yoySchedule,YoYInflationIndexPtr const &index,Period const &lag,Spread spread,DayCounter const &yoyDayCounter,Calendar const &paymentCalendar,BusinessDayConvention paymentConvention=Following){
            boost::shared_ptr<YoYInflationIndex> yoyIndex =
                boost::dynamic_pointer_cast<YoYInflationIndex>(index);
            return new YearOnYearInflationSwapPtr(
                new YearOnYearInflationSwap(type, nominal, fixedSchedule,
                                            fixedRate, fixedDayCounter,
                                            yoySchedule, yoyIndex, lag, spread,
                                            yoyDayCounter, paymentCalendar,
                                            paymentConvention));
        }
SWIGINTERN Rate YearOnYearInflationSwapPtr_fairRate(YearOnYearInflationSwapPtr *self){
            return boost::dynamic_pointer_cast<YearOnYearInflationSwap>(*self)
                ->fairRate();
        }

using QuantLib::YoYInflationCapFloor;
using QuantLib::YoYInflationCap;
using QuantLib::YoYInflationFloor;
using QuantLib::YoYInflationCollar;

typedef boost::shared_ptr<Instrument> YoYInflationCapFloorPtr;
typedef boost::shared_ptr<Instrument> YoYInflationCapPtr;
typedef boost::shared_ptr<Instrument> YoYInflationFloorPtr;
typedef boost::shared_ptr<Instrument> YoYInflationCollarPtr;

SWIGINTERN Volatility YoYInflationCapFloorPtr_impliedVolatility__SWIG_0(YoYInflationCapFloorPtr const *self,Real price,Handle< YoYInflationTermStructure > const &curve,Volatility guess,Real accuracy=1.0e-4,Size maxEvaluations=100,Volatility minVol=1.0e-7,Volatility maxVol=4.0){
             return boost::dynamic_pointer_cast<YoYInflationCapFloor>(*self)->
                 impliedVolatility(price, curve, guess, accuracy,
                                   maxEvaluations, minVol, maxVol);
         }
SWIGINTERN YoYInflationCapPtr *new_YoYInflationCapPtr(std::vector< boost::shared_ptr< CashFlow > > const &leg,std::vector< Rate > const &capRates){
            return new YoYInflationCapPtr(new YoYInflationCap(leg,capRates));
        }
SWIGINTERN YoYInflationFloorPtr *new_YoYInflationFloorPtr(std::vector< boost::shared_ptr< CashFlow > > const &leg,std::vector< Rate > const &floorRates){
            return new YoYInflationFloorPtr(
                                       new YoYInflationFloor(leg,floorRates));
        }
SWIGINTERN YoYInflationCollarPtr *new_YoYInflationCollarPtr(std::vector< boost::shared_ptr< CashFlow > > const &leg,std::vector< Rate > const &capRates,std::vector< Rate > const &floorRates){
            return new YoYInflationCollarPtr(
                             new YoYInflationCollar(leg,capRates,floorRates));
        }

using QuantLib::ShortRateModel;

SWIGINTERN bool boost_shared_ptr_Sl_ShortRateModel_Sg__isNull(boost::shared_ptr< ShortRateModel > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_ShortRateModel_Sg__asObservable(boost::shared_ptr< ShortRateModel > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_ShortRateModel_Sg__asObservable(Handle< ShortRateModel > *self){
        return boost::shared_ptr<Observable>(*self);
    }

    using QuantLib::Vasicek;
    using QuantLib::HullWhite;
    using QuantLib::BlackKarasinski;
    using QuantLib::G2;
    typedef boost::shared_ptr<ShortRateModel> VasicekPtr;
    typedef boost::shared_ptr<ShortRateModel> HullWhitePtr;
    typedef boost::shared_ptr<ShortRateModel> BlackKarasinskiPtr;
    typedef boost::shared_ptr<ShortRateModel> G2Ptr;

SWIGINTERN VasicekPtr *new_VasicekPtr__SWIG_0(Rate r0=0.05,Real a=0.1,Real b=0.05,Real sigma=0.01,Real lambda=0.0){
            return new VasicekPtr(new Vasicek(r0, a, b, sigma, lambda));
        }
SWIGINTERN DiscountFactor VasicekPtr_discount(VasicekPtr const *self,Time t){
            return boost::dynamic_pointer_cast<Vasicek>(*self)->discount(t);
        }
SWIGINTERN Real VasicekPtr_discountBond(VasicekPtr const *self,Time now,Time maturity,Rate rate){
            return boost::dynamic_pointer_cast<Vasicek>(*self)->discountBond(now, maturity, rate);
        }
SWIGINTERN HullWhitePtr *new_HullWhitePtr__SWIG_0(Handle< YieldTermStructure > const &termStructure,Real a=0.1,Real sigma=0.01){
            return new HullWhitePtr(
                new HullWhite(termStructure, a, sigma));
        }
SWIGINTERN DiscountFactor HullWhitePtr_discount(HullWhitePtr const *self,Time t){
            return boost::dynamic_pointer_cast<HullWhite>(*self)->discount(t);
        }
SWIGINTERN Real HullWhitePtr_discountBond(HullWhitePtr const *self,Time now,Time maturity,Rate rate){
            return boost::dynamic_pointer_cast<HullWhite>(*self)->
                                            discountBond(now, maturity, rate);  
        }
SWIGINTERN Rate HullWhitePtr_convexityBias(Real futurePrice,Time t,Time T,Real sigma,Real a){
            return QuantLib::HullWhite::convexityBias(futurePrice, t, T, 
                                                      sigma, a);
        }
SWIGINTERN BlackKarasinskiPtr *new_BlackKarasinskiPtr__SWIG_0(Handle< YieldTermStructure > const &termStructure,Real a=0.1,Real sigma=0.1){
            return new BlackKarasinskiPtr(
                new BlackKarasinski(termStructure, a, sigma));
        }
SWIGINTERN G2Ptr *new_G2Ptr__SWIG_0(Handle< YieldTermStructure > const &termStructure,Real a=0.1,Real sigma=0.01,Real b=0.1,Real eta=0.01,Real rho=-0.75){
            return new G2Ptr(new G2(termStructure, a, sigma, b, eta, rho));
        }
SWIGINTERN DiscountFactor G2Ptr_discount(G2Ptr const *self,Time t){
            return boost::dynamic_pointer_cast<G2>(*self)->discount(t);
        }
SWIGINTERN Real G2Ptr_discountBond(G2Ptr const *self,Time t,Time T,Rate x,Rate y){
            return boost::dynamic_pointer_cast<G2>(*self)->discountBond(t, T, x, y);
        }

using QuantLib::JamshidianSwaptionEngine;
using QuantLib::TreeSwaptionEngine;
using QuantLib::AnalyticCapFloorEngine;
using QuantLib::TreeCapFloorEngine;
using QuantLib::G2SwaptionEngine;
using QuantLib::FdG2SwaptionEngine;
using QuantLib::FdHullWhiteSwaptionEngine;
typedef boost::shared_ptr<PricingEngine> JamshidianSwaptionEnginePtr;
typedef boost::shared_ptr<PricingEngine> TreeSwaptionEnginePtr;
typedef boost::shared_ptr<PricingEngine> AnalyticCapFloorEnginePtr;
typedef boost::shared_ptr<PricingEngine> TreeCapFloorEnginePtr;
typedef boost::shared_ptr<PricingEngine> G2SwaptionEnginePtr;
typedef boost::shared_ptr<PricingEngine> FdG2SwaptionEnginePtr;
typedef boost::shared_ptr<PricingEngine> FdHullWhiteSwaptionEnginePtr;

SWIGINTERN JamshidianSwaptionEnginePtr *new_JamshidianSwaptionEnginePtr__SWIG_0(boost::shared_ptr< ShortRateModel > const &model,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            using QuantLib::OneFactorAffineModel;
            boost::shared_ptr<OneFactorAffineModel> m =
                 boost::dynamic_pointer_cast<OneFactorAffineModel>(model);
            QL_REQUIRE(model, "affine model required");
            return new JamshidianSwaptionEnginePtr(
                               new JamshidianSwaptionEngine(m,termStructure));
        }
SWIGINTERN TreeSwaptionEnginePtr *new_TreeSwaptionEnginePtr__SWIG_0(boost::shared_ptr< ShortRateModel > const &model,Size timeSteps,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            return new TreeSwaptionEnginePtr(
                       new TreeSwaptionEngine(model,timeSteps,termStructure));
        }
SWIGINTERN TreeSwaptionEnginePtr *new_TreeSwaptionEnginePtr__SWIG_2(boost::shared_ptr< ShortRateModel > const &model,TimeGrid const &grid,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            return new TreeSwaptionEnginePtr(
                            new TreeSwaptionEngine(model,grid,termStructure));
        }
SWIGINTERN TreeSwaptionEnginePtr *new_TreeSwaptionEnginePtr__SWIG_4(Handle< ShortRateModel > const &model,Size timeSteps,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            return new TreeSwaptionEnginePtr(
                       new TreeSwaptionEngine(model,timeSteps,termStructure));
        }
SWIGINTERN AnalyticCapFloorEnginePtr *new_AnalyticCapFloorEnginePtr__SWIG_0(boost::shared_ptr< ShortRateModel > const &model,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            using QuantLib::OneFactorAffineModel;
            boost::shared_ptr<OneFactorAffineModel> m =
                 boost::dynamic_pointer_cast<OneFactorAffineModel>(model);
            QL_REQUIRE(model, "affine model required");
            return new AnalyticCapFloorEnginePtr(
                                 new AnalyticCapFloorEngine(m,termStructure));
        }
SWIGINTERN TreeCapFloorEnginePtr *new_TreeCapFloorEnginePtr__SWIG_0(boost::shared_ptr< ShortRateModel > const &model,Size timeSteps,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            return new TreeCapFloorEnginePtr(
                       new TreeCapFloorEngine(model,timeSteps,termStructure));
        }
SWIGINTERN TreeCapFloorEnginePtr *new_TreeCapFloorEnginePtr__SWIG_2(boost::shared_ptr< ShortRateModel > const &model,TimeGrid const &grid,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            return new TreeCapFloorEnginePtr(
                            new TreeCapFloorEngine(model,grid,termStructure));
        }
SWIGINTERN G2SwaptionEnginePtr *new_G2SwaptionEnginePtr(boost::shared_ptr< ShortRateModel > const &model,Real range,Size intervals){
            boost::shared_ptr<G2> g2 =
                boost::dynamic_pointer_cast<G2>(model);
            return new G2SwaptionEnginePtr(
                                    new G2SwaptionEngine(g2,range,intervals));
        }
SWIGINTERN FdG2SwaptionEnginePtr *new_FdG2SwaptionEnginePtr__SWIG_0(boost::shared_ptr< ShortRateModel > const &model,Size tGrid=100,Size xGrid=50,Size yGrid=50,Size dampingSteps=0,Real invEps=1e-5,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){
            boost::shared_ptr<G2> g2 =
                boost::dynamic_pointer_cast<G2>(model);
            return new FdG2SwaptionEnginePtr(
                                    new FdG2SwaptionEngine(g2,tGrid,xGrid,yGrid,dampingSteps,invEps,schemeDesc));
        }
SWIGINTERN FdHullWhiteSwaptionEnginePtr *new_FdHullWhiteSwaptionEnginePtr__SWIG_0(boost::shared_ptr< ShortRateModel > const &model,Size tGrid=100,Size xGrid=100,Size dampingSteps=0,Real invEps=1e-5,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Douglas()){
            boost::shared_ptr<HullWhite> hw =
                boost::dynamic_pointer_cast<HullWhite>(model);
            return new FdHullWhiteSwaptionEnginePtr(
                                    new FdHullWhiteSwaptionEngine(hw,tGrid,xGrid,dampingSteps,invEps,schemeDesc));
        }

using QuantLib::Bond;
using QuantLib::ZeroCouponBond;
using QuantLib::FixedRateBond;
using QuantLib::FloatingRateBond;
using QuantLib::DiscountingBondEngine;

typedef boost::shared_ptr<Instrument> BondPtr;
typedef boost::shared_ptr<Instrument> ZeroCouponBondPtr;
typedef boost::shared_ptr<Instrument> FixedRateBondPtr;
typedef boost::shared_ptr<Instrument> FloatingRateBondPtr;
typedef boost::shared_ptr<PricingEngine> DiscountingBondEnginePtr;

SWIGINTERN BondPtr *new_BondPtr__SWIG_0(Natural settlementDays,Calendar const &calendar,Real faceAmount,Date const &maturityDate,Date const &issueDate=Date(),Leg const &cashflows=Leg()){
            return new BondPtr(new Bond(settlementDays,
                                        calendar,
                                        faceAmount,
                                        maturityDate,
                                        issueDate,
                                        cashflows));
        }
SWIGINTERN Rate BondPtr_nextCouponRate__SWIG_0(BondPtr *self,Date const &d=Date()){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->nextCouponRate();
        }
SWIGINTERN Rate BondPtr_previousCouponRate__SWIG_0(BondPtr *self,Date const &d=Date()){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->previousCouponRate();
        }
SWIGINTERN Natural BondPtr_settlementDays(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->settlementDays();
        }
SWIGINTERN Date BondPtr_settlementDate__SWIG_0(BondPtr *self,Date d=Date()){
            return boost::dynamic_pointer_cast<Bond>(*self)->settlementDate(d);
        }
SWIGINTERN Date BondPtr_startDate(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->startDate();
        }
SWIGINTERN Date BondPtr_maturityDate(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->maturityDate();
        }
SWIGINTERN Date BondPtr_issueDate(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->issueDate();
        }
SWIGINTERN std::vector< boost::shared_ptr< CashFlow > > BondPtr_cashflows(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->cashflows();
        }
SWIGINTERN std::vector< boost::shared_ptr< CashFlow > > BondPtr_redemptions(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->redemptions();
        }
SWIGINTERN boost::shared_ptr< CashFlow > BondPtr_redemption(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->redemption();
        }
SWIGINTERN Calendar BondPtr_calendar(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->calendar();
        }
SWIGINTERN std::vector< Real > BondPtr_notionals(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->notionals();
        }
SWIGINTERN Real BondPtr_notional__SWIG_0(BondPtr const *self,Date d=Date()){
            return boost::dynamic_pointer_cast<Bond>(*self)->notional(d);
        }
SWIGINTERN Real BondPtr_cleanPrice__SWIG_0(BondPtr *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->cleanPrice();
        }
SWIGINTERN Real BondPtr_cleanPrice__SWIG_1(BondPtr *self,Rate yield,DayCounter const &dc,Compounding compounding,Frequency frequency,Date const &settlement=Date()){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->cleanPrice(yield,dc, compounding, frequency, settlement);
        }
SWIGINTERN Real BondPtr_dirtyPrice__SWIG_0(BondPtr *self){
            return boost::dynamic_pointer_cast<Bond>(*self)->dirtyPrice();
        }
SWIGINTERN Real BondPtr_dirtyPrice__SWIG_1(BondPtr *self,Rate yield,DayCounter const &dc,Compounding compounding,Frequency frequency,Date const &settlement=Date()){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->dirtyPrice(yield,dc, compounding,
                             frequency, settlement);
        }
SWIGINTERN Real BondPtr_yield__SWIG_0(BondPtr *self,DayCounter const &dc,Compounding compounding,Frequency freq,Real accuracy=1.0e-8,Size maxEvaluations=100){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->yield(dc,compounding,freq,accuracy,maxEvaluations);
        }
SWIGINTERN Real BondPtr_yield__SWIG_3(BondPtr *self,Real cleanPrice,DayCounter const &dc,Compounding compounding,Frequency freq,Date const &settlement=Date(),Real accuracy=1.0e-8,Size maxEvaluations=100){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->yield(cleanPrice,dc,compounding,freq,
                        settlement,accuracy,maxEvaluations);
        }
SWIGINTERN Real BondPtr_accruedAmount__SWIG_0(BondPtr *self,Date const &settlement=Date()){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->accruedAmount(settlement);
        }
SWIGINTERN Real BondPtr_settlementValue__SWIG_0(BondPtr const *self){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->settlementValue();
        }
SWIGINTERN Real BondPtr_settlementValue__SWIG_1(BondPtr const *self,Real cleanPrice){
            return boost::dynamic_pointer_cast<Bond>(*self)
                ->settlementValue(cleanPrice);
        }


    Real cleanPriceFromZSpread(
                   const BondPtr& bond,
                   const boost::shared_ptr<YieldTermStructure>& discountCurve,
                   Spread zSpread,
                   const DayCounter& dc,
                   Compounding compounding,
                   Frequency freq,
                   const Date& settlementDate = Date()) {
        return QuantLib::BondFunctions::cleanPrice(
                                  *(boost::dynamic_pointer_cast<Bond>(bond)),
                                  discountCurve,
                                  zSpread, dc, compounding,
                                  freq, settlementDate);
    }


SWIGINTERN ZeroCouponBondPtr *new_ZeroCouponBondPtr__SWIG_0(Natural settlementDays,Calendar const &calendar,Real faceAmount,Date const &maturityDate,BusinessDayConvention paymentConvention=QuantLib::Following,Real redemption=100.0,Date const &issueDate=Date()){
            return new ZeroCouponBondPtr(
                new ZeroCouponBond(settlementDays, calendar, faceAmount,
                                   maturityDate,
                                   paymentConvention, redemption,
                                   issueDate));
        }
SWIGINTERN FixedRateBondPtr *new_FixedRateBondPtr__SWIG_0(Integer settlementDays,Real faceAmount,Schedule const &schedule,std::vector< Rate > const &coupons,DayCounter const &paymentDayCounter,BusinessDayConvention paymentConvention=QuantLib::Following,Real redemption=100.0,Date issueDate=Date(),Calendar const &paymentCalendar=Calendar(),Period const &exCouponPeriod=Period(),Calendar const &exCouponCalendar=Calendar(),BusinessDayConvention exCouponConvention=Unadjusted,bool exCouponEndOfMonth=false){
            return new FixedRateBondPtr(
                new FixedRateBond(settlementDays, faceAmount,
                                  schedule, coupons, paymentDayCounter,
                                  paymentConvention, redemption,
                                  issueDate, paymentCalendar,
                                  exCouponPeriod, exCouponCalendar,
                                  exCouponConvention, exCouponEndOfMonth));
        }
SWIGINTERN FixedRateBondPtr *new_FixedRateBondPtr__SWIG_9(Integer settlementDays,Real faceAmount,Schedule const &schedule,std::vector< InterestRate > const &coupons,BusinessDayConvention paymentConvention=Following,Real redemption=100.0,Date const &issueDate=Date(),Calendar const &paymentCalendar=Calendar(),Period const &exCouponPeriod=Period(),Calendar const &exCouponCalendar=Calendar(),BusinessDayConvention exCouponConvention=Unadjusted,bool exCouponEndOfMonth=false){
	       return new FixedRateBondPtr(
		      new FixedRateBond(settlementDays, faceAmount,
		                  schedule, coupons, paymentConvention,
		                  redemption, issueDate, paymentCalendar,
		                  exCouponPeriod, exCouponCalendar,
		                  exCouponConvention, exCouponEndOfMonth));
		}
SWIGINTERN Frequency FixedRateBondPtr_frequency(FixedRateBondPtr const *self){
            return boost::dynamic_pointer_cast<FixedRateBond>(*self)
                ->frequency();
        }
SWIGINTERN DayCounter FixedRateBondPtr_dayCounter(FixedRateBondPtr const *self){
            return boost::dynamic_pointer_cast<FixedRateBond>(*self)
                ->dayCounter();
        }
SWIGINTERN FloatingRateBondPtr *new_FloatingRateBondPtr__SWIG_0(Size settlementDays,Real faceAmount,Schedule const &schedule,IborIndexPtr const &index,DayCounter const &paymentDayCounter,BusinessDayConvention paymentConvention=Following,Size fixingDays=Null< Size >(),std::vector< Real > const &gearings=std::vector< Real >(),std::vector< Spread > const &spreads=std::vector< Spread >(),std::vector< Rate > const &caps=std::vector< Rate >(),std::vector< Rate > const &floors=std::vector< Rate >(),bool inArrears=false,Real redemption=100.0,Date const &issueDate=Date()){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new FloatingRateBondPtr(
                new FloatingRateBond(settlementDays,
                                     faceAmount,
                                     schedule,
                                     libor,
                                     paymentDayCounter,
                                     paymentConvention,
                                     fixingDays,
                                     gearings,
                                     spreads,
                                     caps,
                                     floors,
                                     inArrears,
                                     redemption,
                                     issueDate));
        }

using QuantLib::CmsRateBond;
typedef boost::shared_ptr<Instrument> CmsRateBondPtr;

SWIGINTERN CmsRateBondPtr *new_CmsRateBondPtr__SWIG_0(Size settlementDays,Real faceAmount,Schedule const &schedule,SwapIndexPtr const &index,DayCounter const &paymentDayCounter,BusinessDayConvention paymentConvention,Natural fixingDays,std::vector< Real > const &gearings,std::vector< Spread > const &spreads,std::vector< Rate > const &caps,std::vector< Rate > const &floors,bool inArrears=false,Real redemption=100.0,Date const &issueDate=Date()){
            boost::shared_ptr<SwapIndex> swap =
                boost::dynamic_pointer_cast<SwapIndex>(index);
            return new CmsRateBondPtr(
                new CmsRateBond(settlementDays,
                                faceAmount,
                                schedule,
                                swap,
                                paymentDayCounter,
                                paymentConvention,
                                fixingDays,
                                gearings,
                                spreads,
                                caps,
                                floors,
                                inArrears,
                                redemption,
                                issueDate));
        }
SWIGINTERN DiscountingBondEnginePtr *new_DiscountingBondEnginePtr(Handle< YieldTermStructure > const &discountCurve){
            return new DiscountingBondEnginePtr(
                                    new DiscountingBondEngine(discountCurve));
        }

using QuantLib::CallableBond;
using QuantLib::CallableFixedRateBond;
using QuantLib::TreeCallableFixedRateBondEngine;
using QuantLib::BlackCallableFixedRateBondEngine;
typedef boost::shared_ptr<Instrument> CallableFixedRateBondPtr;
typedef boost::shared_ptr<PricingEngine> TreeCallableFixedRateBondEnginePtr;
typedef boost::shared_ptr<PricingEngine> BlackCallableFixedRateBondEnginePtr;

SWIGINTERN CallableFixedRateBondPtr *new_CallableFixedRateBondPtr(Integer settlementDays,Real faceAmount,Schedule const &schedule,std::vector< Rate > const &coupons,DayCounter const &accrualDayCounter,BusinessDayConvention paymentConvention,Real redemption,Date issueDate,std::vector< boost::shared_ptr< Callability > > const &putCallSchedule){
            return new CallableFixedRateBondPtr(
                new CallableFixedRateBond(settlementDays, faceAmount,
                                          schedule, coupons, accrualDayCounter,
                                          paymentConvention, redemption,
                                          issueDate, putCallSchedule));
        }
SWIGINTERN Real CallableFixedRateBondPtr_OAS__SWIG_0(CallableFixedRateBondPtr *self,Real cleanPrice,Handle< YieldTermStructure > const &engineTS,DayCounter const &dc,Compounding compounding,Frequency freq,Date const &settlementDate=Date(),Real accuracy=1e-10,Size maxIterations=100,Spread guess=0.0){
            return boost::dynamic_pointer_cast<CallableBond>(*self)
                ->OAS(cleanPrice,
                      engineTS,
                      dc, compounding, freq, settlementDate,
                      accuracy,
                      maxIterations,
                      guess);
        }
SWIGINTERN Real CallableFixedRateBondPtr_cleanPriceOAS__SWIG_0(CallableFixedRateBondPtr *self,Real oas,Handle< YieldTermStructure > const &engineTS,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date()){
            return boost::dynamic_pointer_cast<CallableBond>(*self)
                ->cleanPriceOAS(oas,
                                engineTS,
                                dayCounter,
                                compounding,
                                frequency,
                                settlementDate);
        }
SWIGINTERN Real CallableFixedRateBondPtr_effectiveDuration__SWIG_0(CallableFixedRateBondPtr *self,Real oas,Handle< YieldTermStructure > const &engineTS,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Real bump=2e-4){
            return boost::dynamic_pointer_cast<CallableBond>(*self)
                ->effectiveDuration(oas,
                                    engineTS,
                                    dayCounter,
                                    compounding,
                                    frequency,
                                    bump);
        }
SWIGINTERN Real CallableFixedRateBondPtr_effectiveConvexity__SWIG_0(CallableFixedRateBondPtr *self,Real oas,Handle< YieldTermStructure > const &engineTS,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Real bump=2e-4){
            return boost::dynamic_pointer_cast<CallableBond>(*self)
                ->effectiveConvexity(oas,
                                     engineTS,
                                     dayCounter,
                                     compounding,
                                     frequency,
                                     bump);
        }
SWIGINTERN TreeCallableFixedRateBondEnginePtr *new_TreeCallableFixedRateBondEnginePtr__SWIG_0(boost::shared_ptr< ShortRateModel > const &model,Size timeSteps,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            return new TreeCallableFixedRateBondEnginePtr(
                new TreeCallableFixedRateBondEngine(model, timeSteps,
                                                    termStructure));
        }
SWIGINTERN TreeCallableFixedRateBondEnginePtr *new_TreeCallableFixedRateBondEnginePtr__SWIG_2(boost::shared_ptr< ShortRateModel > const &model,TimeGrid const &grid,Handle< YieldTermStructure > const &termStructure=Handle< YieldTermStructure >()){
            return new TreeCallableFixedRateBondEnginePtr(
                new TreeCallableFixedRateBondEngine(model, grid,
                                                    termStructure));
        }
SWIGINTERN BlackCallableFixedRateBondEnginePtr *new_BlackCallableFixedRateBondEnginePtr(Handle< Quote > const &fwdYieldVol,Handle< YieldTermStructure > const &discountCurve){
            return new BlackCallableFixedRateBondEnginePtr(
                new BlackCallableFixedRateBondEngine(fwdYieldVol, discountCurve));
        }

using QuantLib::CPIBond;
typedef boost::shared_ptr<Instrument> CPIBondPtr;

SWIGINTERN CPIBondPtr *new_CPIBondPtr__SWIG_0(Natural settlementDays,Real faceAmount,bool growthOnly,Real baseCPI,Period const &observationLag,ZeroInflationIndexPtr const &cpiIndex,CPI::InterpolationType observationInterpolation,Schedule const &schedule,std::vector< Rate > const &coupons,DayCounter const &accrualDayCounter,BusinessDayConvention paymentConvention=ModifiedFollowing,Date const &issueDate=Date(),Calendar const &paymentCalendar=Calendar(),Period const &exCouponPeriod=Period(),Calendar const &exCouponCalendar=Calendar(),BusinessDayConvention exCouponConvention=Unadjusted,bool exCouponEndOfMonth=false){
            boost::shared_ptr<ZeroInflationIndex> zeroIndex =
                boost::dynamic_pointer_cast<ZeroInflationIndex>(cpiIndex);
            return new CPIBondPtr(
                new CPIBond(settlementDays, faceAmount, growthOnly, baseCPI,
                            observationLag, zeroIndex, observationInterpolation,
                            schedule, coupons, accrualDayCounter,
                            paymentConvention, issueDate, paymentCalendar,
                            exCouponPeriod, exCouponCalendar,
                            exCouponConvention, exCouponEndOfMonth));
        }

using QuantLib::BondFunctions;

SWIGINTERN Date BondFunctions_startDate(BondPtr const &bond){
            return QuantLib::BondFunctions::startDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)));
        }
SWIGINTERN Date BondFunctions_maturityDate(BondPtr const &bond){
            return QuantLib::BondFunctions::maturityDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)));
        }
SWIGINTERN bool BondFunctions_isTradable__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::isTradable(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
SWIGINTERN Date BondFunctions_previousCashFlowDate__SWIG_0(BondPtr const &bond,Date refDate=Date()){
            return QuantLib::BondFunctions::previousCashFlowDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    refDate);
        }
SWIGINTERN Date BondFunctions_nextCashFlowDate__SWIG_0(BondPtr const &bond,Date refDate=Date()){
            return QuantLib::BondFunctions::nextCashFlowDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    refDate);
        }
SWIGINTERN Real BondFunctions_previousCashFlowAmount__SWIG_0(BondPtr const &bond,Date refDate=Date()){
            return QuantLib::BondFunctions::previousCashFlowAmount(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    refDate);
        }
SWIGINTERN Real BondFunctions_nextCashFlowAmount__SWIG_0(BondPtr const &bond,Date refDate=Date()){
            return QuantLib::BondFunctions::nextCashFlowAmount(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    refDate);
        }
SWIGINTERN Rate BondFunctions_previousCouponRate__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::previousCouponRate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
SWIGINTERN Rate BondFunctions_nextCouponRate__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::nextCouponRate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
SWIGINTERN Date BondFunctions_accrualStartDate__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::accrualStartDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
SWIGINTERN Date BondFunctions_accrualEndDate__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::accrualEndDate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
SWIGINTERN Time BondFunctions_accrualPeriod__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::accrualPeriod(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
SWIGINTERN BigInteger BondFunctions_accrualDays__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::accrualDays(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    settlementDate);
        }
SWIGINTERN Time BondFunctions_accruedPeriod__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::accruedPeriod(
                *(boost::dynamic_pointer_cast<Bond>(bond)),
                settlementDate);
        }
SWIGINTERN BigInteger BondFunctions_accruedDays__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){
            return QuantLib::BondFunctions::accruedDays(
                *(boost::dynamic_pointer_cast<Bond>(bond)),
                settlementDate);
        }
SWIGINTERN Real BondFunctions_accruedAmount__SWIG_0(BondPtr const &bond,Date settlementDate=Date()){

            return QuantLib::BondFunctions::accruedAmount(
                *(boost::dynamic_pointer_cast<Bond>(bond)), 
                settlementDate);
        }
SWIGINTERN Real BondFunctions_cleanPrice__SWIG_0(BondPtr const &bond,boost::shared_ptr< YieldTermStructure > const &discountCurve,Date settlementDate=Date()){
            return QuantLib::BondFunctions::cleanPrice(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    *discountCurve,
                    settlementDate);
        }
SWIGINTERN Real BondFunctions_bps__SWIG_0(BondPtr const &bond,boost::shared_ptr< YieldTermStructure > const &discountCurve,Date settlementDate=Date()){
            return QuantLib::BondFunctions::bps(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    *discountCurve,
                    settlementDate);
        }
SWIGINTERN Rate BondFunctions_atmRate__SWIG_0(BondPtr const &bond,boost::shared_ptr< YieldTermStructure > const &discountCurve,Date settlementDate=Date(),Real cleanPrice=Null< Real >()){
            return QuantLib::BondFunctions::atmRate(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    *discountCurve,
                    settlementDate,
                    cleanPrice);
        }
SWIGINTERN Real BondFunctions_cleanPrice__SWIG_2(BondPtr const &bond,InterestRate const &yield,Date settlementDate=Date()){
            return QuantLib::BondFunctions::cleanPrice(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    yield,
                    settlementDate);
        }
SWIGINTERN Real BondFunctions_cleanPrice__SWIG_4(BondPtr const &bond,Rate yield,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date()){
            return QuantLib::BondFunctions::cleanPrice(
                    *(boost::dynamic_pointer_cast<Bond>(bond)),
                    yield,
                    dayCounter,
                    compounding,
                    frequency,
                    settlementDate);
        }
SWIGINTERN Real BondFunctions_bps__SWIG_2(BondPtr const &bond,InterestRate const &yield,Date settlementDate=Date()){
            return QuantLib::BondFunctions::bps(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        settlementDate);
        }
SWIGINTERN Real BondFunctions_bps__SWIG_4(BondPtr const &bond,Rate yield,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date()){
            return QuantLib::BondFunctions::bps(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
SWIGINTERN Rate BondFunctions_yield__SWIG_0(BondPtr const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Size maxIterations=100,Rate guess=0.05){
            return QuantLib::BondFunctions::yield(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        maxIterations,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldBrent__SWIG_0(Brent solver,BondPtr const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Brent>(
                        solver,
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldBisection__SWIG_0(Bisection solver,BondPtr const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Bisection>(
                        solver,
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldFalsePosition__SWIG_0(FalsePosition solver,BondPtr const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<FalsePosition>(
                        solver,
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldRidder__SWIG_0(Ridder solver,BondPtr const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Ridder>(
                        solver,
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldSecant__SWIG_0(Secant solver,BondPtr const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Secant>(
                        solver,
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Time BondFunctions_duration__SWIG_0(BondPtr const &bond,InterestRate const &yield,Duration::Type type=Duration::Modified,Date settlementDate=Date()){
            return QuantLib::BondFunctions::duration(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        type,
                        settlementDate);
        }
SWIGINTERN Time BondFunctions_duration__SWIG_3(BondPtr const &bond,Rate yield,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Duration::Type type=Duration::Modified,Date settlementDate=Date()){
            return QuantLib::BondFunctions::duration(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        type,
                        settlementDate);
        }
SWIGINTERN Real BondFunctions_convexity__SWIG_0(BondPtr const &bond,InterestRate const &yield,Date settlementDate=Date()){
            return QuantLib::BondFunctions::convexity(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        settlementDate);
        }
SWIGINTERN Real BondFunctions_convexity__SWIG_2(BondPtr const &bond,Rate yield,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date()){
            return QuantLib::BondFunctions::convexity(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
SWIGINTERN Real BondFunctions_basisPointValue__SWIG_0(BondPtr const &bond,InterestRate const &yield,Date settlementDate=Date()){
            return QuantLib::BondFunctions::basisPointValue(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        settlementDate);
        }
SWIGINTERN Real BondFunctions_basisPointValue__SWIG_2(BondPtr const &bond,Rate yield,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date()){
            return QuantLib::BondFunctions::basisPointValue(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
SWIGINTERN Real BondFunctions_yieldValueBasisPoint__SWIG_0(BondPtr const &bond,InterestRate const &yield,Date settlementDate=Date()){
            return QuantLib::BondFunctions::yieldValueBasisPoint(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        settlementDate);
        }
SWIGINTERN Real BondFunctions_yieldValueBasisPoint__SWIG_2(BondPtr const &bond,Rate yield,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date()){
            return QuantLib::BondFunctions::yieldValueBasisPoint(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        yield,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate);
        }
SWIGINTERN Spread BondFunctions_zSpread__SWIG_0(BondPtr const &bond,Real cleanPrice,boost::shared_ptr< YieldTermStructure > const &discountCurve,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Size maxIterations=100,Rate guess=0.0){
            return QuantLib::BondFunctions::zSpread(
                        *(boost::dynamic_pointer_cast<Bond>(bond)),
                        cleanPrice,
                        discountCurve,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        maxIterations,
                        guess);

        }

using QuantLib::CapFloor;
using QuantLib::Cap;
using QuantLib::Floor;
using QuantLib::Collar;

typedef boost::shared_ptr<Instrument> CapFloorPtr;
typedef boost::shared_ptr<Instrument> CapPtr;
typedef boost::shared_ptr<Instrument> FloorPtr;
typedef boost::shared_ptr<Instrument> CollarPtr;

SWIGINTERN Volatility CapFloorPtr_impliedVolatility__SWIG_0(CapFloorPtr const *self,Real price,Handle< YieldTermStructure > const &disc,Volatility guess,Real accuracy=1.0e-4,Natural maxEvaluations=100,Volatility minVol=1.0e-7,Volatility maxVol=4.0,VolatilityType type=ShiftedLognormal,Real displacement=0.0){
            return boost::dynamic_pointer_cast<CapFloor>(*self)->
                impliedVolatility(price, disc, guess, accuracy,
                                  maxEvaluations, minVol, maxVol,
                                  type, displacement);
        }
SWIGINTERN Leg const &CapFloorPtr_floatingLeg(CapFloorPtr const *self){
            return boost::dynamic_pointer_cast<CapFloor>(*self)->floatingLeg();
        }
SWIGINTERN std::vector< Rate > const &CapFloorPtr_capRates(CapFloorPtr const *self){
            return boost::dynamic_pointer_cast<CapFloor>(*self)->capRates();
        }
SWIGINTERN std::vector< Rate > const &CapFloorPtr_floorRates(CapFloorPtr const *self){
            return boost::dynamic_pointer_cast<CapFloor>(*self)->floorRates();
        }
SWIGINTERN Date CapFloorPtr_startDate(CapFloorPtr const *self){
            return boost::dynamic_pointer_cast<CapFloor>(*self)->startDate();
        }
SWIGINTERN Date CapFloorPtr_maturityDate(CapFloorPtr const *self){
            return boost::dynamic_pointer_cast<CapFloor>(*self)->maturityDate();
        }
SWIGINTERN Rate CapFloorPtr_atmRate(CapFloorPtr const *self,boost::shared_ptr< YieldTermStructure > const &discountCurve){
            return boost::dynamic_pointer_cast<CapFloor>(*self)->atmRate(*discountCurve);
        }
SWIGINTERN CapPtr *new_CapPtr(std::vector< boost::shared_ptr< CashFlow > > const &leg,std::vector< Rate > const &capRates){
            return new CapPtr(new Cap(leg,capRates));
        }
SWIGINTERN FloorPtr *new_FloorPtr(std::vector< boost::shared_ptr< CashFlow > > const &leg,std::vector< Rate > const &floorRates){
            return new FloorPtr(new Floor(leg,floorRates));
        }
SWIGINTERN CollarPtr *new_CollarPtr(std::vector< boost::shared_ptr< CashFlow > > const &leg,std::vector< Rate > const &capRates,std::vector< Rate > const &floorRates){
            return new CollarPtr(new Collar(leg,capRates,floorRates));
        }

using QuantLib::BlackCapFloorEngine;
typedef boost::shared_ptr<PricingEngine> BlackCapFloorEnginePtr;

SWIGINTERN BlackCapFloorEnginePtr *new_BlackCapFloorEnginePtr__SWIG_0(Handle< YieldTermStructure > const &termStructure,Handle< Quote > const &vol){
            return new BlackCapFloorEnginePtr(
                                  new BlackCapFloorEngine(termStructure,vol));
        }
SWIGINTERN BlackCapFloorEnginePtr *new_BlackCapFloorEnginePtr__SWIG_1(Handle< YieldTermStructure > const &termStructure,Handle< OptionletVolatilityStructure > const &vol){
            return new BlackCapFloorEnginePtr(
                                  new BlackCapFloorEngine(termStructure,vol));
        }

using QuantLib::BachelierCapFloorEngine;
typedef boost::shared_ptr<PricingEngine> BachelierCapFloorEnginePtr;

SWIGINTERN BachelierCapFloorEnginePtr *new_BachelierCapFloorEnginePtr__SWIG_0(Handle< YieldTermStructure > const &termStructure,Handle< Quote > const &vol){
            return new BachelierCapFloorEnginePtr(
                                new BachelierCapFloorEngine(termStructure,vol));
        }
SWIGINTERN BachelierCapFloorEnginePtr *new_BachelierCapFloorEnginePtr__SWIG_1(Handle< YieldTermStructure > const &termStructure,Handle< OptionletVolatilityStructure > const &vol){
            return new BachelierCapFloorEnginePtr(
                                new BachelierCapFloorEngine(termStructure,vol));
        }

using QuantLib::Dividend;

SWIGINTERN bool boost_shared_ptr_Sl_Dividend_Sg__isNull(boost::shared_ptr< Dividend > *self){
                return !(*self);
            }

using QuantLib::FixedDividend;
using QuantLib::FractionalDividend;

typedef boost::shared_ptr<Dividend> FixedDividendPtr;
typedef boost::shared_ptr<Dividend> FractionalDividendPtr;

SWIGINTERN FixedDividendPtr *new_FixedDividendPtr(Real amount,Date const &date){
            return new FixedDividendPtr(new FixedDividend(amount,date));
        }
SWIGINTERN FractionalDividendPtr *new_FractionalDividendPtr(Rate rate,Date const &date){
            return new FractionalDividendPtr(
                                     new FractionalDividend(rate,date));
        }
SWIGINTERN std::vector< boost::shared_ptr< Dividend > > *new_std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<Dividend> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<Dividend> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< Dividend > std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< Dividend > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< Dividend > const &std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__getitem(std::vector< boost::shared_ptr< Dividend > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__setitem(std::vector< boost::shared_ptr< Dividend > > *self,int index,boost::shared_ptr< Dividend > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__AddRange(std::vector< boost::shared_ptr< Dividend > > *self,std::vector< boost::shared_ptr< Dividend > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< Dividend > > *std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__GetRange(std::vector< boost::shared_ptr< Dividend > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<Dividend> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Insert(std::vector< boost::shared_ptr< Dividend > > *self,int index,boost::shared_ptr< Dividend > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< Dividend > > *self,int index,std::vector< boost::shared_ptr< Dividend > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< Dividend > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< Dividend > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< Dividend > > *std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Repeat(boost::shared_ptr< Dividend > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<Dividend> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< Dividend > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< Dividend > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__SetRange(std::vector< boost::shared_ptr< Dividend > > *self,int index,std::vector< boost::shared_ptr< Dividend > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Contains(std::vector< boost::shared_ptr< Dividend > > *self,boost::shared_ptr< Dividend > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< Dividend > > *self,boost::shared_ptr< Dividend > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<Dividend> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< Dividend > > *self,boost::shared_ptr< Dividend > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<Dividend> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Remove(std::vector< boost::shared_ptr< Dividend > > *self,boost::shared_ptr< Dividend > const &value){
        std::vector< boost::shared_ptr<Dividend> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

using QuantLib::ConvertibleZeroCouponBond;
using QuantLib::ConvertibleFixedCouponBond;
using QuantLib::ConvertibleFloatingRateBond;
using QuantLib::BinomialConvertibleEngine;
typedef boost::shared_ptr<Instrument> ConvertibleZeroCouponBondPtr;
typedef boost::shared_ptr<Instrument> ConvertibleFixedCouponBondPtr;
typedef boost::shared_ptr<Instrument> ConvertibleFloatingRateBondPtr;
typedef boost::shared_ptr<PricingEngine> BinomialConvertibleEnginePtr;

SWIGINTERN ConvertibleZeroCouponBondPtr *new_ConvertibleZeroCouponBondPtr__SWIG_0(boost::shared_ptr< Exercise > const &exercise,Real conversionRatio,std::vector< boost::shared_ptr< Dividend > > const &dividends,std::vector< boost::shared_ptr< Callability > > const &callability,Handle< Quote > const &creditSpread,Date const &issueDate,Integer settlementDays,DayCounter const &dayCounter,Schedule const &schedule,Real redemption=100.0){
            return new ConvertibleZeroCouponBondPtr(
                     new ConvertibleZeroCouponBond(exercise, conversionRatio,
                                                   dividends, callability,
                                                   creditSpread,
                                                   issueDate, settlementDays,
                                                   dayCounter, schedule,
                                                   redemption));
        }
SWIGINTERN ConvertibleFixedCouponBondPtr *new_ConvertibleFixedCouponBondPtr__SWIG_0(boost::shared_ptr< Exercise > const &exercise,Real conversionRatio,std::vector< boost::shared_ptr< Dividend > > const &dividends,std::vector< boost::shared_ptr< Callability > > const &callability,Handle< Quote > const &creditSpread,Date const &issueDate,Integer settlementDays,std::vector< Rate > const &coupons,DayCounter const &dayCounter,Schedule const &schedule,Real redemption=100.0){
            return new ConvertibleFixedCouponBondPtr(
                    new ConvertibleFixedCouponBond(exercise, conversionRatio,
                                                   dividends, callability,
                                                   creditSpread,
                                                   issueDate, settlementDays,
                                                   coupons, dayCounter,
                                                   schedule, redemption));
        }
SWIGINTERN ConvertibleFloatingRateBondPtr *new_ConvertibleFloatingRateBondPtr__SWIG_0(boost::shared_ptr< Exercise > const &exercise,Real conversionRatio,std::vector< boost::shared_ptr< Dividend > > const &dividends,std::vector< boost::shared_ptr< Callability > > const &callability,Handle< Quote > const &creditSpread,Date const &issueDate,Integer settlementDays,IborIndexPtr const &index,Integer fixingDays,std::vector< Spread > const &spreads,DayCounter const &dayCounter,Schedule const &schedule,Real redemption=100.0){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new ConvertibleFloatingRateBondPtr(
                   new ConvertibleFloatingRateBond(exercise, conversionRatio,
                                                   dividends, callability,
                                                   creditSpread,
                                                   issueDate, settlementDays,
                                                   libor, fixingDays, spreads,
                                                   dayCounter, schedule,
                                                   redemption));
        }
SWIGINTERN BinomialConvertibleEnginePtr *new_BinomialConvertibleEnginePtr(GeneralizedBlackScholesProcessPtr const &process,std::string const &type,Size steps){
            boost::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 boost::dynamic_pointer_cast<GeneralizedBlackScholesProcess>(
                                                                     process);
            QL_REQUIRE(bsProcess, "Black-Scholes process required");
            std::string s = boost::algorithm::to_lower_copy(type);
            if (s == "crr" || s == "coxrossrubinstein")
                return new BinomialConvertibleEnginePtr(
                    new BinomialConvertibleEngine<CoxRossRubinstein>(
                                                            bsProcess,steps));
            else if (s == "jr" || s == "jarrowrudd")
                return new BinomialConvertibleEnginePtr(
                    new BinomialConvertibleEngine<JarrowRudd>(
                                                            bsProcess,steps));
            else if (s == "eqp")
                return new BinomialConvertibleEnginePtr(
                    new BinomialConvertibleEngine<AdditiveEQPBinomialTree>(
                                                            bsProcess,steps));
            else if (s == "trigeorgis")
                return new BinomialConvertibleEnginePtr(
                    new BinomialConvertibleEngine<Trigeorgis>(
                                                            bsProcess,steps));
            else if (s == "tian")
                return new BinomialConvertibleEnginePtr(
                    new BinomialConvertibleEngine<Tian>(bsProcess,steps));
            else if (s == "lr" || s == "leisenreimer")
                return new BinomialConvertibleEnginePtr(
                    new BinomialConvertibleEngine<LeisenReimer>(
                                                            bsProcess,steps));
            else if (s == "j4" || s == "joshi4")
                return new BinomialConvertibleEnginePtr(
                    new BinomialConvertibleEngine<Joshi4>(bsProcess,steps));
            else
                QL_FAIL("unknown binomial engine type: "+s);
        }

using QuantLib::DefaultProbabilityTermStructure;

SWIGINTERN bool boost_shared_ptr_Sl_DefaultProbabilityTermStructure_Sg__isNull(boost::shared_ptr< DefaultProbabilityTermStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_DefaultProbabilityTermStructure_Sg__asObservable(boost::shared_ptr< DefaultProbabilityTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_DefaultProbabilityTermStructure_Sg__asObservable(Handle< DefaultProbabilityTermStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }

using QuantLib::FlatHazardRate;
typedef boost::shared_ptr<DefaultProbabilityTermStructure> FlatHazardRatePtr;

SWIGINTERN FlatHazardRatePtr *new_FlatHazardRatePtr__SWIG_0(Integer settlementDays,Calendar const &calendar,Handle< Quote > const &hazardRate,DayCounter const &dayCounter){
            return new FlatHazardRatePtr(
                           new FlatHazardRate(settlementDays,calendar,
                                              hazardRate,dayCounter));
        }
SWIGINTERN FlatHazardRatePtr *new_FlatHazardRatePtr__SWIG_1(Date const &todaysDate,Handle< Quote > const &hazardRate,DayCounter const &dayCounter){
            return new FlatHazardRatePtr(
                        new FlatHazardRate(todaysDate,hazardRate,dayCounter));
        }

using QuantLib::InterpolatedHazardRateCurve;


typedef boost::shared_ptr<DefaultProbabilityTermStructure> HazardRateCurvePtr;

SWIGINTERN HazardRateCurvePtr *new_HazardRateCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Real > const &hazardRates,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),BackwardFlat const &i=BackwardFlat()){
            return new HazardRateCurvePtr(
                new InterpolatedHazardRateCurve<BackwardFlat>(dates,hazardRates,
                                                              dayCounter,
                                                              calendar,i));
        }
SWIGINTERN std::vector< Date > const &HazardRateCurvePtr_dates(HazardRateCurvePtr *self){
            typedef InterpolatedHazardRateCurve<BackwardFlat> HazardRateCurve;
            return boost::dynamic_pointer_cast<HazardRateCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Real > const &HazardRateCurvePtr_hazardRates(HazardRateCurvePtr *self){
            typedef InterpolatedHazardRateCurve<BackwardFlat> HazardRateCurve;
            return boost::dynamic_pointer_cast<HazardRateCurve>(*self)->hazardRates();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > HazardRateCurvePtr_nodes(HazardRateCurvePtr *self){
            typedef InterpolatedHazardRateCurve<BackwardFlat> HazardRateCurve;
            return boost::dynamic_pointer_cast<HazardRateCurve>(*self)->nodes();
        }

using QuantLib::InterpolatedDefaultDensityCurve;


typedef boost::shared_ptr<DefaultProbabilityTermStructure> DefaultDensityCurvePtr;

SWIGINTERN DefaultDensityCurvePtr *new_DefaultDensityCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Real > const &densities,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),Linear const &i=Linear()){
            return new DefaultDensityCurvePtr(
                new InterpolatedDefaultDensityCurve<Linear>(dates,
                                                                  densities,
                                                                  dayCounter,
                                                                  calendar,i));
        }
SWIGINTERN std::vector< Date > const &DefaultDensityCurvePtr_dates(DefaultDensityCurvePtr *self){
            typedef InterpolatedDefaultDensityCurve<Linear> DefaultDensityCurve;
            return boost::dynamic_pointer_cast<DefaultDensityCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Real > const &DefaultDensityCurvePtr_defaultDensities(DefaultDensityCurvePtr *self){
            typedef InterpolatedDefaultDensityCurve<Linear> DefaultDensityCurve;
            return boost::dynamic_pointer_cast<DefaultDensityCurve>(*self)->defaultDensities();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > DefaultDensityCurvePtr_nodes(DefaultDensityCurvePtr *self){
            typedef InterpolatedDefaultDensityCurve<Linear> DefaultDensityCurve;
            return boost::dynamic_pointer_cast<DefaultDensityCurve>(*self)->nodes();
        }

using QuantLib::DefaultProbabilityHelper;
using QuantLib::SpreadCdsHelper;
typedef boost::shared_ptr<DefaultProbabilityHelper> SpreadCdsHelperPtr;
using QuantLib::UpfrontCdsHelper;
typedef boost::shared_ptr<DefaultProbabilityHelper> UpfrontCdsHelperPtr;

SWIGINTERN bool boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__isNull(boost::shared_ptr< DefaultProbabilityHelper > *self){
                return !(*self);
            }
SWIGINTERN std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *new_std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<DefaultProbabilityHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<DefaultProbabilityHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< DefaultProbabilityHelper > std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< DefaultProbabilityHelper > const &std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__getitem(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__setitem(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index,boost::shared_ptr< DefaultProbabilityHelper > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__AddRange(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__GetRange(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<DefaultProbabilityHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Insert(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index,boost::shared_ptr< DefaultProbabilityHelper > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index,std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Repeat(boost::shared_ptr< DefaultProbabilityHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<DefaultProbabilityHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__SetRange(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,int index,std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Contains(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,boost::shared_ptr< DefaultProbabilityHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,boost::shared_ptr< DefaultProbabilityHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<DefaultProbabilityHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,boost::shared_ptr< DefaultProbabilityHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<DefaultProbabilityHelper> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Remove(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *self,boost::shared_ptr< DefaultProbabilityHelper > const &value){
        std::vector< boost::shared_ptr<DefaultProbabilityHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN SpreadCdsHelperPtr *new_SpreadCdsHelperPtr__SWIG_0(Handle< Quote > const &spread,Period const &tenor,Integer settlementDays,Calendar const &calendar,Frequency frequency,BusinessDayConvention convention,DateGeneration::Rule rule,DayCounter const &dayCounter,Real recoveryRate,Handle< YieldTermStructure > const &discountCurve,bool settlesAccrual=true,bool paysAtDefaultTime=true){
            return new SpreadCdsHelperPtr(
                new SpreadCdsHelper(spread,tenor,settlementDays,calendar,
                                    frequency,convention,rule,dayCounter,
                                    recoveryRate,discountCurve,
                                    settlesAccrual,paysAtDefaultTime));
        }
SWIGINTERN SpreadCdsHelperPtr *new_SpreadCdsHelperPtr__SWIG_3(Rate spread,Period const &tenor,Integer settlementDays,Calendar const &calendar,Frequency frequency,BusinessDayConvention convention,DateGeneration::Rule rule,DayCounter const &dayCounter,Real recoveryRate,Handle< YieldTermStructure > const &discountCurve,bool settlesAccrual=true,bool paysAtDefaultTime=true){
            return new SpreadCdsHelperPtr(
                new SpreadCdsHelper(spread,tenor,settlementDays,calendar,
                                    frequency,convention,rule,dayCounter,
                                    recoveryRate,discountCurve,
                                    settlesAccrual,paysAtDefaultTime));
        }
SWIGINTERN UpfrontCdsHelperPtr *new_UpfrontCdsHelperPtr__SWIG_0(Handle< Quote > const &upfront,Rate spread,Period const &tenor,Integer settlementDays,Calendar const &calendar,Frequency frequency,BusinessDayConvention convention,DateGeneration::Rule rule,DayCounter const &dayCounter,Real recoveryRate,Handle< YieldTermStructure > const &discountCurve,Natural upfrontSettlementDays=0,bool settlesAccrual=true,bool paysAtDefaultTime=true){
            return new UpfrontCdsHelperPtr(
                new UpfrontCdsHelper(upfront,spread,tenor,
                                     settlementDays,calendar,
                                     frequency,convention,rule,dayCounter,
                                     recoveryRate,discountCurve,upfrontSettlementDays,
                                     settlesAccrual,paysAtDefaultTime));
        }
SWIGINTERN UpfrontCdsHelperPtr *new_UpfrontCdsHelperPtr__SWIG_4(Rate upfront,Rate spread,Period const &tenor,Integer settlementDays,Calendar const &calendar,Frequency frequency,BusinessDayConvention convention,DateGeneration::Rule rule,DayCounter const &dayCounter,Real recoveryRate,Handle< YieldTermStructure > const &discountCurve,Natural upfrontSettlementDays=0,bool settlesAccrual=true,bool paysAtDefaultTime=true){
            return new UpfrontCdsHelperPtr(
                new UpfrontCdsHelper(upfront,spread,tenor,
                                     settlementDays,calendar,
                                     frequency,convention,rule,dayCounter,
                                     recoveryRate,discountCurve,upfrontSettlementDays,
                                     settlesAccrual,paysAtDefaultTime));
        }

using QuantLib::HazardRate;
using QuantLib::DefaultDensity;


using QuantLib::PiecewiseDefaultCurve;


typedef boost::shared_ptr<DefaultProbabilityTermStructure> PiecewiseFlatHazardRatePtr;

SWIGINTERN PiecewiseFlatHazardRatePtr *new_PiecewiseFlatHazardRatePtr__SWIG_0(Date const &referenceDate,std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &instruments,DayCounter const &dayCounter,Real accuracy=1.0e-12,BackwardFlat const &i=BackwardFlat()){
            return new PiecewiseFlatHazardRatePtr(
                new PiecewiseDefaultCurve<HazardRate,BackwardFlat>(
                                                 referenceDate,instruments,
                                                 dayCounter, accuracy, i));
        }
SWIGINTERN PiecewiseFlatHazardRatePtr *new_PiecewiseFlatHazardRatePtr__SWIG_3(Integer settlementDays,Calendar const &calendar,std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &instruments,DayCounter const &dayCounter,Real accuracy=1.0e-12,BackwardFlat const &i=BackwardFlat()){
            return new PiecewiseFlatHazardRatePtr(
                new PiecewiseDefaultCurve<HazardRate,BackwardFlat>(
                                        settlementDays, calendar, instruments,
                                        dayCounter, accuracy, i));
        }
SWIGINTERN std::vector< Date > const &PiecewiseFlatHazardRatePtr_dates(PiecewiseFlatHazardRatePtr *self){
            typedef PiecewiseDefaultCurve<HazardRate,BackwardFlat> PiecewiseFlatHazardRate;
            return boost::dynamic_pointer_cast<PiecewiseFlatHazardRate>(*self)->dates();
        }
SWIGINTERN std::vector< Time > const &PiecewiseFlatHazardRatePtr_times(PiecewiseFlatHazardRatePtr *self){
            typedef PiecewiseDefaultCurve<HazardRate,BackwardFlat> PiecewiseFlatHazardRate;
            return boost::dynamic_pointer_cast<PiecewiseFlatHazardRate>(*self)->times();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > PiecewiseFlatHazardRatePtr_nodes(PiecewiseFlatHazardRatePtr *self){
            typedef PiecewiseDefaultCurve<HazardRate,BackwardFlat> PiecewiseFlatHazardRate;
            return boost::dynamic_pointer_cast<PiecewiseFlatHazardRate>(*self)->nodes();
        }

using QuantLib::Protection;


using QuantLib::CreditDefaultSwap;
using QuantLib::MidPointCdsEngine;
using QuantLib::IntegralCdsEngine;

typedef boost::shared_ptr<Instrument> CreditDefaultSwapPtr;
typedef boost::shared_ptr<PricingEngine> MidPointCdsEnginePtr;
typedef boost::shared_ptr<PricingEngine> IntegralCdsEnginePtr;

SWIGINTERN CreditDefaultSwapPtr *new_CreditDefaultSwapPtr__SWIG_0(Protection::Side side,Real notional,Rate spread,Schedule const &schedule,BusinessDayConvention paymentConvention,DayCounter const &dayCounter,bool settlesAccrual=true,bool paysAtDefaultTime=true){
            return new CreditDefaultSwapPtr(
                    new CreditDefaultSwap(side, notional, spread, schedule,
                                          paymentConvention, dayCounter,
                                          settlesAccrual, paysAtDefaultTime));
        }
SWIGINTERN CreditDefaultSwapPtr *new_CreditDefaultSwapPtr__SWIG_3(Protection::Side side,Real notional,Rate upfront,Rate spread,Schedule const &schedule,BusinessDayConvention paymentConvention,DayCounter const &dayCounter,bool settlesAccrual=true,bool paysAtDefaultTime=true){
            return new CreditDefaultSwapPtr(
                    new CreditDefaultSwap(side, notional, upfront, spread,
                                          schedule, paymentConvention,
                                          dayCounter, settlesAccrual,
                                          paysAtDefaultTime));
        }
SWIGINTERN Protection::Side CreditDefaultSwapPtr_side(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->side();
        }
SWIGINTERN Real CreditDefaultSwapPtr_notional(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->notional();
        }
SWIGINTERN Rate CreditDefaultSwapPtr_runningSpread(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->runningSpread();
        }
SWIGINTERN doubleOrNull CreditDefaultSwapPtr_upfront(CreditDefaultSwapPtr const *self){
            boost::optional<Rate> result =
                boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->upfront();
            if (result)
                return *result;
            else
                return Null<double>();
        }
SWIGINTERN bool CreditDefaultSwapPtr_settlesAccrual(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->settlesAccrual();
        }
SWIGINTERN bool CreditDefaultSwapPtr_paysAtDefaultTime(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->paysAtDefaultTime();
        }
SWIGINTERN Rate CreditDefaultSwapPtr_fairSpread(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->fairSpread();
        }
SWIGINTERN Rate CreditDefaultSwapPtr_fairUpfront(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->fairUpfront();
        }
SWIGINTERN Real CreditDefaultSwapPtr_couponLegBPS(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->couponLegBPS();
        }
SWIGINTERN Real CreditDefaultSwapPtr_couponLegNPV(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->couponLegNPV();
        }
SWIGINTERN Real CreditDefaultSwapPtr_defaultLegNPV(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->defaultLegNPV();
        }
SWIGINTERN Real CreditDefaultSwapPtr_upfrontBPS(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->upfrontBPS();
        }
SWIGINTERN Real CreditDefaultSwapPtr_upfrontNPV(CreditDefaultSwapPtr const *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->upfrontNPV();
        }
SWIGINTERN Rate CreditDefaultSwapPtr_impliedHazardRate__SWIG_0(CreditDefaultSwapPtr const *self,Real targetNPV,Handle< YieldTermStructure > const &discountCurve,DayCounter const &dayCounter,Real recoveryRate=0.4,Real accuracy=1.0e-6){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->impliedHazardRate(targetNPV, discountCurve, dayCounter,
                                    recoveryRate, accuracy);
        }
SWIGINTERN std::vector< boost::shared_ptr< CashFlow > > CreditDefaultSwapPtr_coupons(CreditDefaultSwapPtr *self){
            return boost::dynamic_pointer_cast<CreditDefaultSwap>(*self)
                ->coupons();
        }
SWIGINTERN MidPointCdsEnginePtr *new_MidPointCdsEnginePtr(Handle< DefaultProbabilityTermStructure > const &probability,Real recoveryRate,Handle< YieldTermStructure > const &discountCurve){
            return new MidPointCdsEnginePtr(
                              new MidPointCdsEngine(probability, recoveryRate,
                                                    discountCurve));
        }
SWIGINTERN IntegralCdsEnginePtr *new_IntegralCdsEnginePtr__SWIG_0(Period const &integrationStep,Handle< DefaultProbabilityTermStructure > const &probability,Real recoveryRate,Handle< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows=false){
            return new IntegralCdsEnginePtr(
                              new IntegralCdsEngine(integrationStep, probability,
                                                    recoveryRate, discountCurve,
													includeSettlementDateFlows));
        }

using QuantLib::InterpolatedDiscountCurve;


typedef boost::shared_ptr<YieldTermStructure> DiscountCurvePtr;

SWIGINTERN DiscountCurvePtr *new_DiscountCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< DiscountFactor > const &discounts,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),LogLinear const &i=LogLinear()){
            return new DiscountCurvePtr(
                new InterpolatedDiscountCurve<LogLinear>(dates,discounts,
                                                            dayCounter,
                                                            calendar,i));
        }
SWIGINTERN std::vector< Time > const &DiscountCurvePtr_times(DiscountCurvePtr *self){
            typedef InterpolatedDiscountCurve<LogLinear> DiscountCurve;
            return boost::dynamic_pointer_cast<DiscountCurve>(*self)->times();
        }
SWIGINTERN std::vector< Real > const &DiscountCurvePtr_data(DiscountCurvePtr *self){
            typedef InterpolatedDiscountCurve<LogLinear> DiscountCurve;
            return boost::dynamic_pointer_cast<DiscountCurve>(*self)->data();
        }
SWIGINTERN std::vector< Date > const &DiscountCurvePtr_dates(DiscountCurvePtr *self){
            typedef InterpolatedDiscountCurve<LogLinear> DiscountCurve;
            return boost::dynamic_pointer_cast<DiscountCurve>(*self)->dates();
        }
SWIGINTERN std::vector< DiscountFactor > const &DiscountCurvePtr_discounts(DiscountCurvePtr *self){
            typedef InterpolatedDiscountCurve<LogLinear> DiscountCurve;
            return boost::dynamic_pointer_cast<DiscountCurve>(*self)->discounts();
        }
SWIGINTERN std::vector< std::pair< Date,DiscountFactor > > DiscountCurvePtr_nodes(DiscountCurvePtr *self){
            typedef InterpolatedDiscountCurve<LogLinear> DiscountCurve;
            return boost::dynamic_pointer_cast<DiscountCurve>(*self)->nodes();
        }

using QuantLib::NormalDistribution;
using QuantLib::CumulativeNormalDistribution;
using QuantLib::MoroInverseCumulativeNormal;
using QuantLib::InverseCumulativeNormal;
using QuantLib::BivariateCumulativeNormalDistribution;
using QuantLib::BinomialDistribution;
using QuantLib::CumulativeBinomialDistribution;
using QuantLib::BivariateCumulativeNormalDistributionDr78;
using QuantLib::BivariateCumulativeNormalDistributionWe04DP;
using QuantLib::CumulativeChiSquareDistribution;
using QuantLib::NonCentralCumulativeChiSquareDistribution;
using QuantLib::InverseNonCentralCumulativeChiSquareDistribution;
using QuantLib::CumulativeGammaDistribution;
using QuantLib::GammaFunction;
using QuantLib::PoissonDistribution;
using QuantLib::CumulativePoissonDistribution;
using QuantLib::InverseCumulativePoisson;
using QuantLib::StudentDistribution;
using QuantLib::CumulativeStudentDistribution;
using QuantLib::InverseCumulativeStudent;


using QuantLib::Money;

SWIGINTERN void Money_setConversionType(Money::ConversionType type){
            Money::conversionType = type;
        }
SWIGINTERN void Money_setBaseCurrency(Currency const &c){
            Money::baseCurrency = c;
        }

using QuantLib::ExchangeRate;
using QuantLib::ExchangeRateManager;


using QuantLib::Futures;


using QuantLib::TimeBasket;


using QuantLib::Swap;
using QuantLib::VanillaSwap;
using QuantLib::NonstandardSwap;
using QuantLib::DiscountingSwapEngine;
using QuantLib::FloatFloatSwap;

typedef boost::shared_ptr<Instrument> SwapPtr;
typedef boost::shared_ptr<Instrument> VanillaSwapPtr;
typedef boost::shared_ptr<Instrument> NonstandardSwapPtr;
typedef boost::shared_ptr<PricingEngine> DiscountingSwapEnginePtr;
typedef boost::shared_ptr<Instrument> FloatFloatSwapPtr;

SWIGINTERN SwapPtr *new_SwapPtr(std::vector< boost::shared_ptr< CashFlow > > const &firstLeg,std::vector< boost::shared_ptr< CashFlow > > const &secondLeg){
            return new SwapPtr(new Swap(firstLeg, secondLeg));
        }
SWIGINTERN Date SwapPtr_startDate(SwapPtr *self){
            return boost::dynamic_pointer_cast<Swap>(*self)->startDate();
        }
SWIGINTERN Date SwapPtr_maturityDate(SwapPtr *self){
            return boost::dynamic_pointer_cast<Swap>(*self)->maturityDate();
        }
SWIGINTERN Leg const &SwapPtr_leg(SwapPtr *self,Size i){
            return boost::dynamic_pointer_cast<Swap>(*self)->leg(i);
        }
SWIGINTERN Real SwapPtr_legNPV(SwapPtr const *self,Size j){
            return boost::dynamic_pointer_cast<Swap>(*self)->legNPV(j);
        }
SWIGINTERN VanillaSwapPtr *new_VanillaSwapPtr(VanillaSwap::Type type,Real nominal,Schedule const &fixedSchedule,Rate fixedRate,DayCounter const &fixedDayCount,Schedule const &floatSchedule,IborIndexPtr const &index,Spread spread,DayCounter const &floatingDayCount){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new VanillaSwapPtr(
                    new VanillaSwap(type, nominal,fixedSchedule,fixedRate,
                                    fixedDayCount,floatSchedule,libor,
                                    spread, floatingDayCount));
        }
SWIGINTERN Rate VanillaSwapPtr_fairRate(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap>(*self)->fairRate();
        }
SWIGINTERN Spread VanillaSwapPtr_fairSpread(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap>(*self)
                 ->fairSpread();
        }
SWIGINTERN Real VanillaSwapPtr_fixedLegBPS(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap>(*self)
                 ->fixedLegBPS();
        }
SWIGINTERN Real VanillaSwapPtr_floatingLegBPS(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap>(*self)
                 ->floatingLegBPS();
        }
SWIGINTERN Real VanillaSwapPtr_fixedLegNPV(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->fixedLegNPV();
        }
SWIGINTERN Real VanillaSwapPtr_floatingLegNPV(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->floatingLegNPV();
        }
SWIGINTERN Leg const &VanillaSwapPtr_fixedLeg(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->fixedLeg();
        }
SWIGINTERN Leg const &VanillaSwapPtr_floatingLeg(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->floatingLeg();
        }
SWIGINTERN Real VanillaSwapPtr_nominal(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->nominal();
        }
SWIGINTERN Schedule const &VanillaSwapPtr_fixedSchedule(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->fixedSchedule();
        }
SWIGINTERN Schedule const &VanillaSwapPtr_floatingSchedule(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->floatingSchedule();
        }
SWIGINTERN Rate VanillaSwapPtr_fixedRate(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->fixedRate();
        }
SWIGINTERN Spread VanillaSwapPtr_spread(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->spread();
        }
SWIGINTERN DayCounter const &VanillaSwapPtr_floatingDayCount(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->floatingDayCount();
        }
SWIGINTERN DayCounter const &VanillaSwapPtr_fixedDayCount(VanillaSwapPtr *self){
            return boost::dynamic_pointer_cast<VanillaSwap> (*self)
                ->fixedDayCount();
        }
SWIGINTERN NonstandardSwapPtr *new_NonstandardSwapPtr__SWIG_0(VanillaSwap::Type type,std::vector< Real > const &fixedNominal,std::vector< Real > const &floatingNominal,Schedule const &fixedSchedule,std::vector< Real > const &fixedRate,DayCounter const &fixedDayCount,Schedule const &floatSchedule,IborIndexPtr const &index,std::vector< Real > const &gearing,std::vector< Spread > const &spread,DayCounter const &floatDayCount,bool const intermediateCapitalExchange=false,bool const finalCapitalExchange=false,BusinessDayConvention paymentConvention=Following){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new NonstandardSwapPtr(
                new NonstandardSwap(type,fixedNominal,floatingNominal,fixedSchedule,fixedRate,
                                    fixedDayCount,floatSchedule,libor,gearing,
                                    spread,floatDayCount,intermediateCapitalExchange,
                                    finalCapitalExchange, paymentConvention));
        }
SWIGINTERN Leg const &NonstandardSwapPtr_fixedLeg(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->fixedLeg();
        }
SWIGINTERN Leg const &NonstandardSwapPtr_floatingLeg(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->floatingLeg();
        }
SWIGINTERN std::vector< Real > NonstandardSwapPtr_fixedNominals(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->fixedNominal();
        }
SWIGINTERN std::vector< Real > NonstandardSwapPtr_floatingNominals(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->floatingNominal();
        }
SWIGINTERN Schedule const &NonstandardSwapPtr_fixedSchedule(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->fixedSchedule();
        }
SWIGINTERN Schedule const &NonstandardSwapPtr_floatingSchedule(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->floatingSchedule();
        }
SWIGINTERN std::vector< Rate > NonstandardSwapPtr_fixedRate(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->fixedRate();
        }
SWIGINTERN std::vector< Spread > NonstandardSwapPtr_spreads(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->spreads();
        }
SWIGINTERN std::vector< Spread > NonstandardSwapPtr_gearings(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->gearings();
        }
SWIGINTERN DayCounter const &NonstandardSwapPtr_floatingDayCount(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->floatingDayCount();
        }
SWIGINTERN DayCounter const &NonstandardSwapPtr_fixedDayCount(NonstandardSwapPtr *self){
            return boost::dynamic_pointer_cast<NonstandardSwap> (*self)
                ->fixedDayCount();
        }
SWIGINTERN DiscountingSwapEnginePtr *new_DiscountingSwapEnginePtr__SWIG_0(Handle< YieldTermStructure > const &discountCurve,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return new DiscountingSwapEnginePtr(
                                    new DiscountingSwapEngine(discountCurve,
                                                              boost::none,
                                                              settlementDate,
                                                              npvDate));
        }
SWIGINTERN DiscountingSwapEnginePtr *new_DiscountingSwapEnginePtr__SWIG_3(Handle< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return new DiscountingSwapEnginePtr(
                         new DiscountingSwapEngine(discountCurve,
                                                   includeSettlementDateFlows,
                                                   settlementDate,
                                                   npvDate));
        }

using QuantLib::AssetSwap;
typedef boost::shared_ptr<Instrument> AssetSwapPtr;

SWIGINTERN AssetSwapPtr *new_AssetSwapPtr__SWIG_0(bool payFixedRate,BondPtr const &bond,Real bondCleanPrice,InterestRateIndexPtr const &index,Spread spread,Schedule const &floatSchedule=Schedule(),DayCounter const &floatingDayCount=DayCounter(),bool parAssetSwap=true){
            const boost::shared_ptr<Bond> b =
                boost::dynamic_pointer_cast<Bond>(bond);
            const boost::shared_ptr<IborIndex> i =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new AssetSwapPtr(
                new AssetSwap(payFixedRate,b,bondCleanPrice,i,spread,
                              floatSchedule,floatingDayCount,parAssetSwap));
        }
SWIGINTERN Real AssetSwapPtr_fairCleanPrice(AssetSwapPtr *self){
            return boost::dynamic_pointer_cast<AssetSwap>(*self)
                ->fairCleanPrice();
        }
SWIGINTERN Spread AssetSwapPtr_fairSpread(AssetSwapPtr *self){
            return boost::dynamic_pointer_cast<AssetSwap>(*self)
                ->fairSpread();
        }
SWIGINTERN FloatFloatSwapPtr *new_FloatFloatSwapPtr__SWIG_0(VanillaSwap::Type type,std::vector< Real > const &nominal1,std::vector< Real > const &nominal2,Schedule const &schedule1,InterestRateIndexPtr const &indexPtr1,DayCounter const &dayCount1,Schedule const &schedule2,InterestRateIndexPtr const &indexPtr2,DayCounter const &dayCount2,bool const intermediateCapitalExchange=false,bool const finalCapitalExchange=false,std::vector< Real > const &gearing1=std::vector< Real >(),std::vector< Real > const &spread1=std::vector< Real >(),std::vector< Real > const &cappedRate1=std::vector< Real >(),std::vector< Real > const &flooredRate1=std::vector< Real >(),std::vector< Real > const &gearing2=std::vector< Real >(),std::vector< Real > const &spread2=std::vector< Real >(),std::vector< Real > const &cappedRate2=std::vector< Real >(),std::vector< Real > const &flooredRate2=std::vector< Real >(),BusinessDayConvention paymentConvention1=Following,BusinessDayConvention paymentConvention2=Following){
            boost::shared_ptr<InterestRateIndex> index1 =
                boost::dynamic_pointer_cast<InterestRateIndex>(indexPtr1);
            boost::shared_ptr<InterestRateIndex> index2 =
                boost::dynamic_pointer_cast<InterestRateIndex>(indexPtr2);
            return new FloatFloatSwapPtr(
                    new FloatFloatSwap(type, nominal1,nominal2,schedule1,
                                    index1,dayCount1,schedule2,
                                    index2, dayCount2,
                                    intermediateCapitalExchange, finalCapitalExchange,
                                    gearing1, spread1, cappedRate1,
                                    flooredRate1, gearing2, spread2,
                                    cappedRate2, flooredRate2,
                                    paymentConvention1, paymentConvention2));
        }

using QuantLib::Pillar;
using QuantLib::RateHelper;
using QuantLib::DepositRateHelper;
using QuantLib::FraRateHelper;
using QuantLib::FuturesRateHelper;
using QuantLib::SwapRateHelper;
using QuantLib::BondHelper;
using QuantLib::FixedRateBondHelper;
using QuantLib::OISRateHelper;
using QuantLib::DatedOISRateHelper;
using QuantLib::FxSwapRateHelper;
typedef boost::shared_ptr<RateHelper> DepositRateHelperPtr;
typedef boost::shared_ptr<RateHelper> FraRateHelperPtr;
typedef boost::shared_ptr<RateHelper> FuturesRateHelperPtr;
typedef boost::shared_ptr<RateHelper> SwapRateHelperPtr;
typedef boost::shared_ptr<RateHelper> BondHelperPtr;
typedef boost::shared_ptr<RateHelper> FixedRateBondHelperPtr;
typedef boost::shared_ptr<RateHelper> OISRateHelperPtr;
typedef boost::shared_ptr<RateHelper> DatedOISRateHelperPtr;
typedef boost::shared_ptr<RateHelper> FxSwapRateHelperPtr;

SWIGINTERN bool boost_shared_ptr_Sl_RateHelper_Sg__isNull(boost::shared_ptr< RateHelper > *self){
                return !(*self);
            }
SWIGINTERN DepositRateHelperPtr *new_DepositRateHelperPtr__SWIG_0(Handle< Quote > const &rate,Period const &tenor,Natural fixingDays,Calendar const &calendar,BusinessDayConvention convention,bool endOfMonth,DayCounter const &dayCounter){
            return new DepositRateHelperPtr(
                new DepositRateHelper(rate,tenor,fixingDays,
                                      calendar,convention,
                                      endOfMonth, dayCounter));
        }
SWIGINTERN DepositRateHelperPtr *new_DepositRateHelperPtr__SWIG_1(Rate rate,Period const &tenor,Natural fixingDays,Calendar const &calendar,BusinessDayConvention convention,bool endOfMonth,DayCounter const &dayCounter){
            return new DepositRateHelperPtr(
                new DepositRateHelper(rate, tenor, fixingDays,
                                      calendar, convention,
                                      endOfMonth, dayCounter));
        }
SWIGINTERN DepositRateHelperPtr *new_DepositRateHelperPtr__SWIG_2(Handle< Quote > const &rate,IborIndexPtr const &index){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new DepositRateHelperPtr(
                new DepositRateHelper(rate, libor));
        }
SWIGINTERN DepositRateHelperPtr *new_DepositRateHelperPtr__SWIG_3(Rate rate,IborIndexPtr const &index){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new DepositRateHelperPtr(
                new DepositRateHelper(rate, libor));
        }
SWIGINTERN FraRateHelperPtr *new_FraRateHelperPtr__SWIG_0(Handle< Quote > const &rate,Natural monthsToStart,Natural monthsToEnd,Natural fixingDays,Calendar const &calendar,BusinessDayConvention convention,bool endOfMonth,DayCounter const &dayCounter){
            return new FraRateHelperPtr(
                new FraRateHelper(rate,monthsToStart,monthsToEnd,
                                  fixingDays,calendar,convention,
                                  endOfMonth,dayCounter));
        }
SWIGINTERN FraRateHelperPtr *new_FraRateHelperPtr__SWIG_1(Rate rate,Natural monthsToStart,Natural monthsToEnd,Natural fixingDays,Calendar const &calendar,BusinessDayConvention convention,bool endOfMonth,DayCounter const &dayCounter){
            return new FraRateHelperPtr(
                new FraRateHelper(rate,monthsToStart,monthsToEnd,
                                  fixingDays,calendar,convention,
                                  endOfMonth,dayCounter));
        }
SWIGINTERN FraRateHelperPtr *new_FraRateHelperPtr__SWIG_2(Handle< Quote > const &rate,Natural monthsToStart,IborIndexPtr const &index){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new FraRateHelperPtr(
                new FraRateHelper(rate,monthsToStart,libor));
        }
SWIGINTERN FraRateHelperPtr *new_FraRateHelperPtr__SWIG_3(Rate rate,Natural monthsToStart,IborIndexPtr const &index){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new FraRateHelperPtr(
                new FraRateHelper(rate,monthsToStart,libor));
        }
SWIGINTERN FuturesRateHelperPtr *new_FuturesRateHelperPtr__SWIG_0(Handle< Quote > const &price,Date const &iborStartDate,Natural nMonths,Calendar const &calendar,BusinessDayConvention convention,bool endOfMonth,DayCounter const &dayCounter,Handle< Quote > const &convexityAdjustment,Futures::Type type=Futures::IMM){
            return new FuturesRateHelperPtr(
                new FuturesRateHelper(price,iborStartDate,nMonths,
                                      calendar,convention,endOfMonth,
                                      dayCounter,convexityAdjustment,type));
        }
SWIGINTERN FuturesRateHelperPtr *new_FuturesRateHelperPtr__SWIG_2(Real price,Date const &iborStartDate,Natural nMonths,Calendar const &calendar,BusinessDayConvention convention,bool endOfMonth,DayCounter const &dayCounter,Rate convexityAdjustment=0.0,Futures::Type type=Futures::IMM){
            return new FuturesRateHelperPtr(
                new FuturesRateHelper(price,iborStartDate,nMonths,
                                      calendar,convention,endOfMonth,
                                      dayCounter,convexityAdjustment,type));
        }
SWIGINTERN FuturesRateHelperPtr *new_FuturesRateHelperPtr__SWIG_5(Handle< Quote > const &price,Date const &iborStartDate,Date const &iborEndDate,DayCounter const &dayCounter,Handle< Quote > const &convexityAdjustment,Futures::Type type=Futures::IMM){
            return new FuturesRateHelperPtr(
                new FuturesRateHelper(price,iborStartDate,iborEndDate,
                                      dayCounter,convexityAdjustment,type));
        }
SWIGINTERN FuturesRateHelperPtr *new_FuturesRateHelperPtr__SWIG_7(Real price,Date const &iborStartDate,Date const &iborEndDate,DayCounter const &dayCounter,Rate convexityAdjustment=0.0,Futures::Type type=Futures::IMM){
            return new FuturesRateHelperPtr(
                new FuturesRateHelper(price,iborStartDate,iborEndDate,
                                      dayCounter,convexityAdjustment,type));
        }
SWIGINTERN FuturesRateHelperPtr *new_FuturesRateHelperPtr__SWIG_10(Handle< Quote > const &price,Date const &iborStartDate,IborIndexPtr const &index,Handle< Quote > const &convexityAdjustment,Futures::Type type=Futures::IMM){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new FuturesRateHelperPtr(
                new FuturesRateHelper(price,iborStartDate,libor,
                                      convexityAdjustment,type));
        }
SWIGINTERN FuturesRateHelperPtr *new_FuturesRateHelperPtr__SWIG_12(Real price,Date const &iborStartDate,IborIndexPtr const &index,Real convexityAdjustment=0.0,Futures::Type type=Futures::IMM){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new FuturesRateHelperPtr(
                new FuturesRateHelper(price,iborStartDate,libor,
                                      convexityAdjustment,type));
        }
SWIGINTERN SwapRateHelperPtr *new_SwapRateHelperPtr__SWIG_0(Handle< Quote > const &rate,Period const &tenor,Calendar const &calendar,Frequency fixedFrequency,BusinessDayConvention fixedConvention,DayCounter const &fixedDayCount,IborIndexPtr const &index,Handle< Quote > const &spread=Handle< Quote >(),Period const &fwdStart=0*Days,Handle< YieldTermStructure > const &discountingCurve=Handle< YieldTermStructure >(),Natural settlementDays=Null< Natural >(),Pillar::Choice pillar=Pillar::LastRelevantDate,Date customPillarDate=Date()){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new SwapRateHelperPtr(
                new SwapRateHelper(rate, tenor, calendar,
                                   fixedFrequency, fixedConvention,
                                   fixedDayCount, libor,
                                   spread, fwdStart,
                                   discountingCurve, settlementDays,
                                   pillar, customPillarDate));
        }
SWIGINTERN SwapRateHelperPtr *new_SwapRateHelperPtr__SWIG_7(Rate rate,Period const &tenor,Calendar const &calendar,Frequency fixedFrequency,BusinessDayConvention fixedConvention,DayCounter const &fixedDayCount,IborIndexPtr const &index,Handle< Quote > const &spread=Handle< Quote >(),Period const &fwdStart=0*Days,Handle< YieldTermStructure > const &discountingCurve=Handle< YieldTermStructure >(),Natural settlementDays=Null< Natural >(),Pillar::Choice pillar=Pillar::LastRelevantDate,Date customPillarDate=Date()){
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new SwapRateHelperPtr(
                new SwapRateHelper(rate, tenor, calendar,
                                   fixedFrequency, fixedConvention,
                                   fixedDayCount, libor,
                                   spread, fwdStart,
                                   discountingCurve, settlementDays,
                                   pillar, customPillarDate));
        }
SWIGINTERN SwapRateHelperPtr *new_SwapRateHelperPtr__SWIG_14(Handle< Quote > const &rate,SwapIndexPtr const &index,Handle< Quote > const &spread=Handle< Quote >(),Period const &fwdStart=0*Days,Handle< YieldTermStructure > const &discountingCurve=Handle< YieldTermStructure >(),Pillar::Choice pillar=Pillar::LastRelevantDate,Date customPillarDate=Date()){
            boost::shared_ptr<SwapIndex> swapIndex =
                boost::dynamic_pointer_cast<SwapIndex>(index);
            return new SwapRateHelperPtr(
                new SwapRateHelper(rate, swapIndex,
                                   spread, fwdStart,
                                   discountingCurve,
                                   pillar, customPillarDate));
        }
SWIGINTERN SwapRateHelperPtr *new_SwapRateHelperPtr__SWIG_20(Rate rate,SwapIndexPtr const &index,Handle< Quote > const &spread=Handle< Quote >(),Period const &fwdStart=0*Days,Handle< YieldTermStructure > const &discountingCurve=Handle< YieldTermStructure >(),Pillar::Choice pillar=Pillar::LastRelevantDate,Date customPillarDate=Date()){
            boost::shared_ptr<SwapIndex> swapIndex =
                boost::dynamic_pointer_cast<SwapIndex>(index);
            return new SwapRateHelperPtr(
                new SwapRateHelper(rate, swapIndex,
                                   spread, fwdStart,
                                   discountingCurve,
                                   pillar, customPillarDate));
        }
SWIGINTERN VanillaSwapPtr SwapRateHelperPtr_swap(SwapRateHelperPtr *self){
            return boost::dynamic_pointer_cast<SwapRateHelper>(*self)->swap();
        }
SWIGINTERN BondHelperPtr *new_BondHelperPtr__SWIG_0(Handle< Quote > const &cleanPrice,BondPtr const &bond,bool useCleanPrice=true){
            boost::shared_ptr<Bond> b = boost::dynamic_pointer_cast<Bond>(bond);
            return new BondHelperPtr(
                new BondHelper(cleanPrice, b, useCleanPrice));
        }
SWIGINTERN BondPtr BondHelperPtr_bond(BondHelperPtr *self){
            return BondPtr(boost::dynamic_pointer_cast<BondHelper>(*self)->bond());
        }
SWIGINTERN FixedRateBondHelperPtr *new_FixedRateBondHelperPtr__SWIG_0(Handle< Quote > const &cleanPrice,Size settlementDays,Real faceAmount,Schedule const &schedule,std::vector< Rate > const &coupons,DayCounter const &paymentDayCounter,BusinessDayConvention paymentConvention=Following,Real redemption=100.0,Date const &issueDate=Date(),Calendar const &paymentCalendar=Calendar(),Period const &exCouponPeriod=Period(),Calendar const &exCouponCalendar=Calendar(),BusinessDayConvention exCouponConvention=Unadjusted,bool exCouponEndOfMonth=false,bool useCleanPrice=true){
            return new FixedRateBondHelperPtr(
                new FixedRateBondHelper(cleanPrice, settlementDays, faceAmount,
                                        schedule, coupons, paymentDayCounter,
                                        paymentConvention, redemption,
                                        issueDate, paymentCalendar,
                                        exCouponPeriod, exCouponCalendar,
                                        exCouponConvention, exCouponEndOfMonth,
                                        useCleanPrice));
        }
SWIGINTERN FixedRateBondPtr FixedRateBondHelperPtr_bond(FixedRateBondHelperPtr *self){
            return FixedRateBondPtr(boost::dynamic_pointer_cast<FixedRateBondHelper>(*self)->bond());
        }
SWIGINTERN OISRateHelperPtr *new_OISRateHelperPtr__SWIG_0(Natural settlementDays,Period const &tenor,Handle< Quote > const &rate,OvernightIndexPtr const &index,Handle< YieldTermStructure > const &discountingCurve=Handle< YieldTermStructure >(),bool telescopicValueDates=false,Natural paymentLag=0,BusinessDayConvention paymentConvention=Following,Frequency paymentFrequency=Annual,Calendar const &paymentCalendar=Calendar(),Period const &forwardStart=0*Days,Spread const overnightSpread=0.0){
            boost::shared_ptr<OvernightIndex> overnight =
                boost::dynamic_pointer_cast<OvernightIndex>(index);
            return new OISRateHelperPtr(
                new OISRateHelper(settlementDays,tenor,rate,
                                  overnight,discountingCurve,
                                  telescopicValueDates, paymentLag,
                                  paymentConvention, paymentFrequency,
                                  paymentCalendar, forwardStart,
                                  overnightSpread));
        }
SWIGINTERN DatedOISRateHelperPtr *new_DatedOISRateHelperPtr__SWIG_0(Date const &startDate,Date const &endDate,Handle< Quote > const &rate,OvernightIndexPtr const &index,Handle< YieldTermStructure > const &discountingCurve=Handle< YieldTermStructure >()){
            boost::shared_ptr<OvernightIndex> overnight =
                boost::dynamic_pointer_cast<OvernightIndex>(index);
            return new DatedOISRateHelperPtr(
                new DatedOISRateHelper(startDate,endDate,rate,
                                       overnight,discountingCurve));
        }
SWIGINTERN FxSwapRateHelperPtr *new_FxSwapRateHelperPtr__SWIG_0(Handle< Quote > const &fwdPoint,Handle< Quote > const &spotFx,Period const &tenor,Natural fixingDays,Calendar const &calendar,BusinessDayConvention convention,bool endOfMonth,bool isFxBaseCurrencyCollateralCurrency,Handle< YieldTermStructure > const &coll=Handle< YieldTermStructure >(),Calendar const &tradingCalendar=Calendar()){
            return new FxSwapRateHelperPtr(
                new FxSwapRateHelper(fwdPoint, spotFx, tenor,
                                     fixingDays, calendar, convention,
                                     endOfMonth,
                                     isFxBaseCurrencyCollateralCurrency,
                                     coll, tradingCalendar));
        }
SWIGINTERN std::vector< boost::shared_ptr< RateHelper > > *new_std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr<RateHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr<RateHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RateHelper > std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RateHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN boost::shared_ptr< RateHelper > const &std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__getitem(std::vector< boost::shared_ptr< RateHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__setitem(std::vector< boost::shared_ptr< RateHelper > > *self,int index,boost::shared_ptr< RateHelper > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RateHelper > > *self,std::vector< boost::shared_ptr< RateHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RateHelper > > *std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RateHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr<RateHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Insert(std::vector< boost::shared_ptr< RateHelper > > *self,int index,boost::shared_ptr< RateHelper > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RateHelper > > *self,int index,std::vector< boost::shared_ptr< RateHelper > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RateHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RateHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RateHelper > > *std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Repeat(boost::shared_ptr< RateHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr<RateHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RateHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RateHelper > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RateHelper > > *self,int index,std::vector< boost::shared_ptr< RateHelper > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Contains(std::vector< boost::shared_ptr< RateHelper > > *self,boost::shared_ptr< RateHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__IndexOf(std::vector< boost::shared_ptr< RateHelper > > *self,boost::shared_ptr< RateHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<RateHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__LastIndexOf(std::vector< boost::shared_ptr< RateHelper > > *self,boost::shared_ptr< RateHelper > const &value){
        int index = -1;
        std::vector< boost::shared_ptr<RateHelper> >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Remove(std::vector< boost::shared_ptr< RateHelper > > *self,boost::shared_ptr< RateHelper > const &value){
        std::vector< boost::shared_ptr<RateHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }

using QuantLib::FittedBondDiscountCurve;

typedef boost::shared_ptr<YieldTermStructure> FittedBondDiscountCurvePtr;
typedef QuantLib::FittedBondDiscountCurve::FittingMethod FittingMethod;

std::vector<boost::shared_ptr<BondHelper> > convert_bond_helpers(
                 const std::vector<boost::shared_ptr<RateHelper> >& helpers) {
    std::vector<boost::shared_ptr<BondHelper> > result(helpers.size());
    for (Size i=0; i<helpers.size(); ++i)
        result[i] = boost::dynamic_pointer_cast<BondHelper>(helpers[i]);
    return result;
}

SWIGINTERN FittedBondDiscountCurvePtr *new_FittedBondDiscountCurvePtr__SWIG_0(Natural settlementDays,Calendar const &calendar,std::vector< boost::shared_ptr< RateHelper > > const &helpers,DayCounter const &dayCounter,FittingMethod const &fittingMethod,Real accuracy=1.0e-10,Size maxEvaluations=10000,Array const &guess=Array(),Real simplexLambda=1.0){
            return new FittedBondDiscountCurvePtr(
                new FittedBondDiscountCurve(settlementDays,
                                            calendar,
                                            convert_bond_helpers(helpers),
                                            dayCounter,
                                            fittingMethod,
                                            accuracy,
                                            maxEvaluations,
                                            guess,
                                            simplexLambda));
        }
SWIGINTERN FittedBondDiscountCurvePtr *new_FittedBondDiscountCurvePtr__SWIG_5(Date const &referenceDate,std::vector< boost::shared_ptr< RateHelper > > const &helpers,DayCounter const &dayCounter,FittingMethod const &fittingMethod,Real accuracy=1.0e-10,Size maxEvaluations=10000,Array const &guess=Array(),Real simplexLambda=1.0){
            return new FittedBondDiscountCurvePtr(
                new FittedBondDiscountCurve(referenceDate,
                                            convert_bond_helpers(helpers),
                                            dayCounter,
                                            fittingMethod,
                                            accuracy,
                                            maxEvaluations,
                                            guess,
                                            simplexLambda));
        }
SWIGINTERN FittingMethod const &FittedBondDiscountCurvePtr_fitResults(FittedBondDiscountCurvePtr const *self){
            return boost::dynamic_pointer_cast<FittedBondDiscountCurve>(*self)
                ->fitResults();
        }

using QuantLib::ExponentialSplinesFitting;
using QuantLib::NelsonSiegelFitting;
using QuantLib::SvenssonFitting;
using QuantLib::CubicBSplinesFitting;
using QuantLib::SimplePolynomialFitting;


using QuantLib::InterpolatedForwardCurve;


typedef boost::shared_ptr<YieldTermStructure> ForwardCurvePtr;

SWIGINTERN ForwardCurvePtr *new_ForwardCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Rate > const &forwards,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),BackwardFlat const &i=BackwardFlat()){
            return new ForwardCurvePtr(
                new InterpolatedForwardCurve<BackwardFlat>(dates,forwards,
                                                           dayCounter,
                                                           calendar,i));
        }
SWIGINTERN std::vector< Date > const &ForwardCurvePtr_dates(ForwardCurvePtr *self){
            typedef InterpolatedForwardCurve<BackwardFlat> ForwardCurve;
            return boost::dynamic_pointer_cast<ForwardCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Rate > const &ForwardCurvePtr_forwards(ForwardCurvePtr *self){
            typedef InterpolatedForwardCurve<BackwardFlat> ForwardCurve;
            return boost::dynamic_pointer_cast<ForwardCurve>(*self)->forwards();
        }
SWIGINTERN std::vector< std::pair< Date,Rate > > ForwardCurvePtr_nodes(ForwardCurvePtr *self){
            typedef InterpolatedForwardCurve<BackwardFlat> ForwardCurve;
            return boost::dynamic_pointer_cast<ForwardCurve>(*self)->nodes();
        }

using QuantLib::Position;
using QuantLib::ForwardRateAgreement;
typedef boost::shared_ptr<Instrument> ForwardRateAgreementPtr;

SWIGINTERN ForwardRateAgreementPtr *new_ForwardRateAgreementPtr__SWIG_0(Date const &valueDate,Date const &maturityDate,Position::Type type,Rate strikeForwardRate,Real notionalAmount,IborIndexPtr const &index,Handle< YieldTermStructure > const &discountCurve=Handle< YieldTermStructure >()){
             
            boost::shared_ptr<IborIndex> libor =
                boost::dynamic_pointer_cast<IborIndex>(index);

            return new ForwardRateAgreementPtr(
                   new ForwardRateAgreement(valueDate, maturityDate, type,
                                            strikeForwardRate, notionalAmount,
                                            libor, discountCurve));
        }
SWIGINTERN Real ForwardRateAgreementPtr_spotIncome(ForwardRateAgreementPtr const *self,Handle< YieldTermStructure > const &discount){
            return boost::dynamic_pointer_cast<ForwardRateAgreement>(*self)
                ->spotIncome(discount);
        }
SWIGINTERN Real ForwardRateAgreementPtr_spotValue(ForwardRateAgreementPtr const *self){
            return boost::dynamic_pointer_cast<ForwardRateAgreement>(*self)
                ->spotValue();
        }
SWIGINTERN InterestRate ForwardRateAgreementPtr_forwardRate(ForwardRateAgreementPtr const *self){
            return boost::dynamic_pointer_cast<ForwardRateAgreement>(*self)
                ->forwardRate();
        }

using QuantLib::Gaussian1dModel;


SWIGINTERN bool boost_shared_ptr_Sl_Gaussian1dModel_Sg__isNull(boost::shared_ptr< Gaussian1dModel > *self){
                return !(*self);
            }

using QuantLib::Gsr;
using QuantLib::MarkovFunctional;

typedef boost::shared_ptr<Gaussian1dModel> GsrPtr;
typedef boost::shared_ptr<Gaussian1dModel> MarkovFunctionalPtr;

SWIGINTERN GsrPtr *new_GsrPtr__SWIG_0(Handle< YieldTermStructure > const &termStructure,std::vector< Date > const &volstepdates,std::vector< Handle< Quote > > const &volatilities,std::vector< Handle< Quote > > const &reversions,Real const T=60.0){
            return new GsrPtr(new Gsr(termStructure, volstepdates,
                                      volatilities, reversions, T));
        }
SWIGINTERN void GsrPtr_calibrateVolatilitiesIterative__SWIG_0(GsrPtr *self,std::vector< boost::shared_ptr< CalibrationHelper > > const &helpers,OptimizationMethod &method,EndCriteria const &endCriteria,Constraint const &constraint=Constraint(),std::vector< Real > const &weights=std::vector< Real >()){
            boost::dynamic_pointer_cast<Gsr>(*self)
                ->calibrateVolatilitiesIterative(helpers, method, endCriteria,
                                                 constraint, weights);
        }
SWIGINTERN void GsrPtr_calibrate__SWIG_0(GsrPtr *self,std::vector< boost::shared_ptr< CalibrationHelper > > const &helpers,OptimizationMethod &method,EndCriteria const &endCriteria,Constraint const &constraint=Constraint(),std::vector< Real > const &weights=std::vector< Real >(),std::vector< bool > const &fixParameters=std::vector< bool >()){
            boost::dynamic_pointer_cast<Gsr>(*self)
                ->calibrate(helpers, method, endCriteria,
                            constraint, weights, fixParameters);
        }
SWIGINTERN Array GsrPtr_params(GsrPtr const *self){
            return boost::dynamic_pointer_cast<Gsr>(*self)->params();
        }
SWIGINTERN Real GsrPtr_value(GsrPtr *self,Array const &params,std::vector< boost::shared_ptr< CalibrationHelper > > const &helpers){
            return boost::dynamic_pointer_cast<Gsr>(*self)->value(params, helpers);
        }
SWIGINTERN EndCriteria::Type GsrPtr_endCriteria(GsrPtr const *self){
            return boost::dynamic_pointer_cast<Gsr>(*self)->endCriteria();
        }
SWIGINTERN void GsrPtr_setParams(GsrPtr *self,Array const &params){
            boost::dynamic_pointer_cast<Gsr>(*self)->setParams(params);
        }
SWIGINTERN Integer GsrPtr_functionEvaluation(GsrPtr const *self){
            return boost::dynamic_pointer_cast<Gsr>(*self)->functionEvaluation();
        }
SWIGINTERN Array const &GsrPtr_reversion(GsrPtr const *self){
            return boost::dynamic_pointer_cast<Gsr>(*self)->reversion();
        }
SWIGINTERN Array const &GsrPtr_volatility(GsrPtr const *self){
            return boost::dynamic_pointer_cast<Gsr>(*self)->volatility();
        }
SWIGINTERN MarkovFunctionalPtr *new_MarkovFunctionalPtr__SWIG_0(Handle< YieldTermStructure > const &termStructure,Real const reversion,std::vector< Date > const &volstepdates,std::vector< Real > const &volatilities,Handle< SwaptionVolatilityStructure > const &swaptionVol,std::vector< Date > const &swaptionExpiries,std::vector< Period > const &swaptionTenors,SwapIndexPtr const &swapIndexBase,Size const yGridPoints=64,Real const yStdDevs=7.0,Size const gaussHermitePoints=32,Real const digitalGap=1E-5,Real const marketRateAccuracy=1E-7,Real const lowerRateBound=0.0,Real const upperRateBound=2.0,int const adjustments=MarkovFunctional::ModelSettings::KahaleSmile|MarkovFunctional::ModelSettings::SmileExponentialExtrapolation,std::vector< Real > const &smileMoneyCheckpoints=std::vector< Real >()){
            const boost::shared_ptr<SwapIndex> swapIndex =
                boost::dynamic_pointer_cast<SwapIndex>(swapIndexBase);
            MarkovFunctional::ModelSettings modelSettings =
                MarkovFunctional::ModelSettings(yGridPoints, yStdDevs,
                                                gaussHermitePoints, digitalGap,
                                                marketRateAccuracy,
                                                lowerRateBound,
                                                upperRateBound,
                                                adjustments,
                                                smileMoneyCheckpoints);
            return new MarkovFunctionalPtr(
                new MarkovFunctional(termStructure, reversion,
                                     volstepdates, volatilities,
                                     swaptionVol, swaptionExpiries,
                                     swaptionTenors, swapIndex,
                                     modelSettings));
        }
SWIGINTERN void MarkovFunctionalPtr_calibrate__SWIG_0(MarkovFunctionalPtr *self,std::vector< boost::shared_ptr< CalibrationHelper > > const &helper,OptimizationMethod &method,EndCriteria const &endCriteria,Constraint const &constraint=Constraint(),std::vector< Real > const &weights=std::vector< Real >(),std::vector< bool > const &fixParameters=std::vector< bool >()){
            boost::dynamic_pointer_cast<MarkovFunctional>(*self)->calibrate(helper, method, 
                                                                            endCriteria, constraint, weights, fixParameters);
        }
SWIGINTERN Array const &MarkovFunctionalPtr_volatility(MarkovFunctionalPtr const *self){
            return boost::dynamic_pointer_cast<MarkovFunctional>(*self)
                ->volatility();
        }

using QuantLib::Gaussian1dSwaptionEngine;
using QuantLib::Gaussian1dJamshidianSwaptionEngine;
using QuantLib::Gaussian1dNonstandardSwaptionEngine;
using QuantLib::Gaussian1dFloatFloatSwaptionEngine;
 
typedef boost::shared_ptr<PricingEngine> Gaussian1dSwaptionEnginePtr;
typedef boost::shared_ptr<PricingEngine> Gaussian1dJamshidianSwaptionEnginePtr;
typedef boost::shared_ptr<PricingEngine> Gaussian1dNonstandardSwaptionEnginePtr;
typedef boost::shared_ptr<PricingEngine> Gaussian1dFloatFloatSwaptionEnginePtr;

SWIGINTERN Gaussian1dSwaptionEnginePtr *new_Gaussian1dSwaptionEnginePtr__SWIG_0(boost::shared_ptr< Gaussian1dModel > const &model,int const integrationPoints=64,Real const stddevs=7.0,bool const extrapolatePayoff=true,bool const flatPayoffExtrapolation=false,Handle< YieldTermStructure > const &discountCurve=Handle< YieldTermStructure >()){
            return new Gaussian1dSwaptionEnginePtr(new Gaussian1dSwaptionEngine(model, integrationPoints, 
                    stddevs, extrapolatePayoff, flatPayoffExtrapolation, discountCurve));
        }
SWIGINTERN Gaussian1dJamshidianSwaptionEnginePtr *new_Gaussian1dJamshidianSwaptionEnginePtr(boost::shared_ptr< Gaussian1dModel > const &model){
            return new Gaussian1dJamshidianSwaptionEnginePtr(new Gaussian1dJamshidianSwaptionEngine(model));
        }
SWIGINTERN Gaussian1dNonstandardSwaptionEnginePtr *new_Gaussian1dNonstandardSwaptionEnginePtr__SWIG_0(boost::shared_ptr< Gaussian1dModel > const &model,int const integrationPoints=64,Real const stddevs=7.0,bool const extrapolatePayoff=true,bool const flatPayoffExtrapolation=false,Handle< Quote > const &oas=Handle< Quote >(),Handle< YieldTermStructure > const &discountCurve=Handle< YieldTermStructure >()){
            return new Gaussian1dNonstandardSwaptionEnginePtr(new Gaussian1dNonstandardSwaptionEngine(model, integrationPoints, 
                    stddevs, extrapolatePayoff, flatPayoffExtrapolation, oas, discountCurve));
        }
SWIGINTERN Gaussian1dFloatFloatSwaptionEnginePtr *new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0(boost::shared_ptr< Gaussian1dModel > const &model,int const integrationPoints=64,Real const stddevs=7.0,bool const extrapolatePayoff=true,bool const flatPayoffExtrapolation=false,Handle< Quote > const &oas=Handle< Quote >(),Handle< YieldTermStructure > const &discountCurve=Handle< YieldTermStructure >(),bool const includeTodaysExercise=false,Gaussian1dFloatFloatSwaptionEngine::Probabilities const probabilities=Gaussian1dFloatFloatSwaptionEngine::None){
            return new Gaussian1dFloatFloatSwaptionEnginePtr(
                new Gaussian1dFloatFloatSwaptionEngine(model,
                                                       integrationPoints,
                                                       stddevs,
                                                       extrapolatePayoff,
                                                       flatPayoffExtrapolation,
                                                       oas,
                                                       discountCurve,
                                                       includeTodaysExercise,
                                                       probabilities));
        }

using QuantLib::SegmentIntegral;
using QuantLib::TrapezoidIntegral;
using QuantLib::Default;
using QuantLib::MidPoint;
using QuantLib::SimpsonIntegral;
using QuantLib::GaussKronrodAdaptive;
using QuantLib::GaussKronrodNonAdaptive;
using QuantLib::GaussLobattoIntegral;
using QuantLib::GaussLaguerreIntegration;
using QuantLib::GaussHermiteIntegration;
using QuantLib::GaussJacobiIntegration;
using QuantLib::GaussHyperbolicIntegration;
using QuantLib::GaussLegendreIntegration;
using QuantLib::GaussChebyshevIntegration;
using QuantLib::GaussChebyshev2ndIntegration;
using QuantLib::GaussGegenbauerIntegration;


using QuantLib::Sample;

using QuantLib::LecuyerUniformRng;
using QuantLib::KnuthUniformRng;
using QuantLib::MersenneTwisterUniformRng;

typedef QuantLib::PseudoRandom::urng_type UniformRandomGenerator;

using QuantLib::CLGaussianRng;
using QuantLib::BoxMullerGaussianRng;
using QuantLib::InverseCumulativeRng;

typedef QuantLib::PseudoRandom::rng_type GaussianRandomGenerator;

using QuantLib::RandomSequenceGenerator;

typedef QuantLib::PseudoRandom::ursg_type UniformRandomSequenceGenerator;
using QuantLib::SobolBrownianGenerator;

using QuantLib::HaltonRsg;
using QuantLib::SobolRsg;
using QuantLib::SobolBrownianBridgeRsg;

typedef QuantLib::LowDiscrepancy::ursg_type
    UniformLowDiscrepancySequenceGenerator;

using QuantLib::InverseCumulativeRsg;

typedef QuantLib::PseudoRandom::rsg_type GaussianRandomSequenceGenerator;
typedef QuantLib::LowDiscrepancy::rsg_type
    GaussianLowDiscrepancySequenceGenerator;

SWIGINTERN double Sample_Sl_Real_Sg__value(Sample< Real > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_Real_Sg__weight(Sample< Real > *self){ return self->weight; }
SWIGINTERN Array Sample_Sl_Array_Sg__value(Sample< Array > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_Array_Sg__weight(Sample< Array > *self){ return self->weight; }
SWIGINTERN std::vector< double > Sample_Sl_std_vector_Sl_Real_Sg__Sg__value(Sample< std::vector< Real > > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_std_vector_Sl_Real_Sg__Sg__weight(Sample< std::vector< Real > > *self){ return self->weight; }
SWIGINTERN Real UniformRandomGenerator_nextValue(UniformRandomGenerator const *self){
			return (*self).next().value;
		}
SWIGINTERN Real GaussianRandomGenerator_nextValue(GaussianRandomGenerator const *self){
			return (*self).next().value;
		}
SWIGINTERN std::vector< unsigned int > SobolRsg_nextInt32Sequence(SobolRsg *self){
        const std::vector<boost::uint_least32_t> &tmp = self->nextInt32Sequence();
        std::vector<unsigned int> outp(tmp.size());
        std::copy(tmp.begin(),tmp.end(),outp.begin());
        return outp;
      }

Matrix getCovariance(const Array& volatilities, const Matrix& correlations) {
    return QuantLib::getCovariance(volatilities.begin(),
                                   volatilities.end(),
                                   correlations);
}


using QuantLib::Path;


typedef QuantLib::PathGenerator<GaussianRandomSequenceGenerator>
    GaussianPathGenerator;

SWIGINTERN Path Sample_Sl_Path_Sg__value(Sample< Path > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_Path_Sg__weight(Sample< Path > *self){ return self->weight; }
SWIGINTERN GaussianPathGenerator *new_GaussianPathGenerator(StochasticProcess1DPtr const &process,Time length,Size steps,GaussianRandomSequenceGenerator const &rsg,bool brownianBridge){
            boost::shared_ptr<StochasticProcess1D> process1d =
                boost::dynamic_pointer_cast<StochasticProcess1D>(process);
            return new GaussianPathGenerator(process1d,length,steps,
                                             rsg,brownianBridge);
        }

typedef QuantLib::PathGenerator<GaussianLowDiscrepancySequenceGenerator>
    GaussianSobolPathGenerator;

SWIGINTERN GaussianSobolPathGenerator *new_GaussianSobolPathGenerator(StochasticProcess1DPtr const &process,Time length,Size steps,GaussianLowDiscrepancySequenceGenerator const &rsg,bool brownianBridge){
            boost::shared_ptr<StochasticProcess1D> process1d =
                boost::dynamic_pointer_cast<StochasticProcess1D>(process);
            return new GaussianSobolPathGenerator(process1d,length,steps,
                                                  rsg,brownianBridge);
        }

using QuantLib::MultiPath;


typedef QuantLib::MultiPathGenerator<GaussianRandomSequenceGenerator>
    GaussianMultiPathGenerator;

SWIGINTERN MultiPath Sample_Sl_MultiPath_Sg__value(Sample< MultiPath > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_MultiPath_Sg__weight(Sample< MultiPath > *self){ return self->weight; }
SWIGINTERN GaussianMultiPathGenerator *new_GaussianMultiPathGenerator__SWIG_0(boost::shared_ptr< StochasticProcess > const &process,std::vector< Time > const &times,GaussianRandomSequenceGenerator const &generator,bool brownianBridge=false){
          return new GaussianMultiPathGenerator(process,
                                                QuantLib::TimeGrid(
                                                    times.begin(),
                                                    times.end()),
                                                generator,
                                                brownianBridge);
      }

using QuantLib::BrownianBridge;

SWIGINTERN std::vector< Real > BrownianBridge_transform(BrownianBridge *self,std::vector< Real > const &input){
      std::vector<Real> outp(input.size());
      self->transform(input.begin(),input.end(),outp.begin());
      return outp;
    }
SWIGINTERN std::vector< unsigned int > BrownianBridge_bridgeIndex(BrownianBridge const *self){
    	const std::vector<Size> &tmp = self->bridgeIndex();
    	std::vector<unsigned int> outp(tmp.size());
    	std::copy(tmp.begin(), tmp.end(), outp.begin());
    	return outp;
    }
SWIGINTERN std::vector< unsigned int > BrownianBridge_leftIndex(BrownianBridge const *self){
    	const std::vector<Size> &tmp = self->leftIndex();
    	std::vector<unsigned int> outp(tmp.size());
    	std::copy(tmp.begin(), tmp.end(), outp.begin());
    	return outp;
    }
SWIGINTERN std::vector< unsigned int > BrownianBridge_rightIndex(BrownianBridge const *self){
    	const std::vector<Size> &tmp = self->rightIndex();
    	std::vector<unsigned int> outp(tmp.size());
    	std::copy(tmp.begin(), tmp.end(), outp.begin());
    	return outp;
    }

typedef QuantLib::BoundaryCondition<QuantLib::TridiagonalOperator>
        DefaultBoundaryCondition;

SWIGINTERN bool boost_shared_ptr_Sl_DefaultBoundaryCondition_Sg__isNull(boost::shared_ptr< DefaultBoundaryCondition > *self){
                return !(*self);
            }

using QuantLib::NeumannBC;
using QuantLib::DirichletBC;
typedef boost::shared_ptr<DefaultBoundaryCondition> NeumannBCPtr;
typedef boost::shared_ptr<DefaultBoundaryCondition> DirichletBCPtr;

SWIGINTERN NeumannBCPtr *new_NeumannBCPtr(Real value,DefaultBoundaryCondition::Side side){
            return new NeumannBCPtr(new NeumannBC(value, side));
        }
SWIGINTERN DirichletBCPtr *new_DirichletBCPtr(Real value,DefaultBoundaryCondition::Side side){
            return new DirichletBCPtr(new DirichletBC(value, side));
        }

using QuantLib::TridiagonalOperator;


using QuantLib::DPlus;
using QuantLib::DMinus;
using QuantLib::DZero;
using QuantLib::DPlusDMinus;


using QuantLib::Discount;
using QuantLib::ZeroYield;
using QuantLib::ForwardRate;


using QuantLib::PiecewiseYieldCurve;


typedef boost::shared_ptr<YieldTermStructure> PiecewiseFlatForwardPtr;

SWIGINTERN PiecewiseFlatForwardPtr *new_PiecewiseFlatForwardPtr__SWIG_0(Date const &referenceDate,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,BackwardFlat const &i=BackwardFlat()){
            return new PiecewiseFlatForwardPtr(
                new PiecewiseYieldCurve<ForwardRate,BackwardFlat>(
                                                 referenceDate,instruments,
                                                 dayCounter, jumps, jumpDates,
                                                 accuracy,i));
        }
SWIGINTERN PiecewiseFlatForwardPtr *new_PiecewiseFlatForwardPtr__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,BackwardFlat const &i=BackwardFlat()){
            return new PiecewiseFlatForwardPtr(
                new PiecewiseYieldCurve<ForwardRate,BackwardFlat>(
                                        settlementDays, calendar, instruments,
                                        dayCounter, jumps, jumpDates,
                                        accuracy, i));
        }
SWIGINTERN std::vector< Date > const &PiecewiseFlatForwardPtr_dates(PiecewiseFlatForwardPtr *self){
            typedef PiecewiseYieldCurve<ForwardRate,BackwardFlat> PiecewiseFlatForward;
            return boost::dynamic_pointer_cast<PiecewiseFlatForward>(*self)->dates();
        }
SWIGINTERN std::vector< Time > const &PiecewiseFlatForwardPtr_times(PiecewiseFlatForwardPtr *self){
            typedef PiecewiseYieldCurve<ForwardRate,BackwardFlat> PiecewiseFlatForward;
            return boost::dynamic_pointer_cast<PiecewiseFlatForward>(*self)->times();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > PiecewiseFlatForwardPtr_nodes(PiecewiseFlatForwardPtr *self){
            typedef PiecewiseYieldCurve<ForwardRate,BackwardFlat> PiecewiseFlatForward;
            return boost::dynamic_pointer_cast<PiecewiseFlatForward>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> PiecewiseLinearForwardPtr;

SWIGINTERN PiecewiseLinearForwardPtr *new_PiecewiseLinearForwardPtr__SWIG_0(Date const &referenceDate,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,Linear const &i=Linear()){
            return new PiecewiseLinearForwardPtr(
                new PiecewiseYieldCurve<ForwardRate,Linear>(
                                                 referenceDate,instruments,
                                                 dayCounter, jumps, jumpDates,
                                                 accuracy,i));
        }
SWIGINTERN PiecewiseLinearForwardPtr *new_PiecewiseLinearForwardPtr__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,Linear const &i=Linear()){
            return new PiecewiseLinearForwardPtr(
                new PiecewiseYieldCurve<ForwardRate,Linear>(
                                        settlementDays, calendar, instruments,
                                        dayCounter, jumps, jumpDates,
                                        accuracy, i));
        }
SWIGINTERN std::vector< Date > const &PiecewiseLinearForwardPtr_dates(PiecewiseLinearForwardPtr *self){
            typedef PiecewiseYieldCurve<ForwardRate,Linear> PiecewiseLinearForward;
            return boost::dynamic_pointer_cast<PiecewiseLinearForward>(*self)->dates();
        }
SWIGINTERN std::vector< Time > const &PiecewiseLinearForwardPtr_times(PiecewiseLinearForwardPtr *self){
            typedef PiecewiseYieldCurve<ForwardRate,Linear> PiecewiseLinearForward;
            return boost::dynamic_pointer_cast<PiecewiseLinearForward>(*self)->times();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > PiecewiseLinearForwardPtr_nodes(PiecewiseLinearForwardPtr *self){
            typedef PiecewiseYieldCurve<ForwardRate,Linear> PiecewiseLinearForward;
            return boost::dynamic_pointer_cast<PiecewiseLinearForward>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> PiecewiseLinearZeroPtr;

SWIGINTERN PiecewiseLinearZeroPtr *new_PiecewiseLinearZeroPtr__SWIG_0(Date const &referenceDate,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,Linear const &i=Linear()){
            return new PiecewiseLinearZeroPtr(
                new PiecewiseYieldCurve<ZeroYield,Linear>(
                                                 referenceDate,instruments,
                                                 dayCounter, jumps, jumpDates,
                                                 accuracy,i));
        }
SWIGINTERN PiecewiseLinearZeroPtr *new_PiecewiseLinearZeroPtr__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,Linear const &i=Linear()){
            return new PiecewiseLinearZeroPtr(
                new PiecewiseYieldCurve<ZeroYield,Linear>(
                                        settlementDays, calendar, instruments,
                                        dayCounter, jumps, jumpDates,
                                        accuracy, i));
        }
SWIGINTERN std::vector< Date > const &PiecewiseLinearZeroPtr_dates(PiecewiseLinearZeroPtr *self){
            typedef PiecewiseYieldCurve<ZeroYield,Linear> PiecewiseLinearZero;
            return boost::dynamic_pointer_cast<PiecewiseLinearZero>(*self)->dates();
        }
SWIGINTERN std::vector< Time > const &PiecewiseLinearZeroPtr_times(PiecewiseLinearZeroPtr *self){
            typedef PiecewiseYieldCurve<ZeroYield,Linear> PiecewiseLinearZero;
            return boost::dynamic_pointer_cast<PiecewiseLinearZero>(*self)->times();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > PiecewiseLinearZeroPtr_nodes(PiecewiseLinearZeroPtr *self){
            typedef PiecewiseYieldCurve<ZeroYield,Linear> PiecewiseLinearZero;
            return boost::dynamic_pointer_cast<PiecewiseLinearZero>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> PiecewiseCubicZeroPtr;

SWIGINTERN PiecewiseCubicZeroPtr *new_PiecewiseCubicZeroPtr__SWIG_0(Date const &referenceDate,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,Cubic const &i=Cubic()){
            return new PiecewiseCubicZeroPtr(
                new PiecewiseYieldCurve<ZeroYield,Cubic>(
                                                 referenceDate,instruments,
                                                 dayCounter, jumps, jumpDates,
                                                 accuracy,i));
        }
SWIGINTERN PiecewiseCubicZeroPtr *new_PiecewiseCubicZeroPtr__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,Cubic const &i=Cubic()){
            return new PiecewiseCubicZeroPtr(
                new PiecewiseYieldCurve<ZeroYield,Cubic>(
                                        settlementDays, calendar, instruments,
                                        dayCounter, jumps, jumpDates,
                                        accuracy, i));
        }
SWIGINTERN std::vector< Date > const &PiecewiseCubicZeroPtr_dates(PiecewiseCubicZeroPtr *self){
            typedef PiecewiseYieldCurve<ZeroYield,Cubic> PiecewiseCubicZero;
            return boost::dynamic_pointer_cast<PiecewiseCubicZero>(*self)->dates();
        }
SWIGINTERN std::vector< Time > const &PiecewiseCubicZeroPtr_times(PiecewiseCubicZeroPtr *self){
            typedef PiecewiseYieldCurve<ZeroYield,Cubic> PiecewiseCubicZero;
            return boost::dynamic_pointer_cast<PiecewiseCubicZero>(*self)->times();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > PiecewiseCubicZeroPtr_nodes(PiecewiseCubicZeroPtr *self){
            typedef PiecewiseYieldCurve<ZeroYield,Cubic> PiecewiseCubicZero;
            return boost::dynamic_pointer_cast<PiecewiseCubicZero>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> PiecewiseLogCubicDiscountPtr;

SWIGINTERN PiecewiseLogCubicDiscountPtr *new_PiecewiseLogCubicDiscountPtr__SWIG_0(Date const &referenceDate,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,MonotonicLogCubic const &i=MonotonicLogCubic()){
            return new PiecewiseLogCubicDiscountPtr(
                new PiecewiseYieldCurve<Discount,MonotonicLogCubic>(
                                                 referenceDate,instruments,
                                                 dayCounter, jumps, jumpDates,
                                                 accuracy,i));
        }
SWIGINTERN PiecewiseLogCubicDiscountPtr *new_PiecewiseLogCubicDiscountPtr__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< boost::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date > const &jumpDates=std::vector< Date >(),Real accuracy=1.0e-12,MonotonicLogCubic const &i=MonotonicLogCubic()){
            return new PiecewiseLogCubicDiscountPtr(
                new PiecewiseYieldCurve<Discount,MonotonicLogCubic>(
                                        settlementDays, calendar, instruments,
                                        dayCounter, jumps, jumpDates,
                                        accuracy, i));
        }
SWIGINTERN std::vector< Date > const &PiecewiseLogCubicDiscountPtr_dates(PiecewiseLogCubicDiscountPtr *self){
            typedef PiecewiseYieldCurve<Discount,MonotonicLogCubic> PiecewiseLogCubicDiscount;
            return boost::dynamic_pointer_cast<PiecewiseLogCubicDiscount>(*self)->dates();
        }
SWIGINTERN std::vector< Time > const &PiecewiseLogCubicDiscountPtr_times(PiecewiseLogCubicDiscountPtr *self){
            typedef PiecewiseYieldCurve<Discount,MonotonicLogCubic> PiecewiseLogCubicDiscount;
            return boost::dynamic_pointer_cast<PiecewiseLogCubicDiscount>(*self)->times();
        }
SWIGINTERN std::vector< std::pair< Date,Real > > PiecewiseLogCubicDiscountPtr_nodes(PiecewiseLogCubicDiscountPtr *self){
            typedef PiecewiseYieldCurve<Discount,MonotonicLogCubic> PiecewiseLogCubicDiscount;
            return boost::dynamic_pointer_cast<PiecewiseLogCubicDiscount>(*self)->nodes();
        }

using QuantLib::Settings;

SWIGINTERN Date Settings_getEvaluationDate(Settings *self){
            return self->evaluationDate();
        }
SWIGINTERN void Settings_setEvaluationDate(Settings *self,Date const &d){
            self->evaluationDate() = d;
        }
SWIGINTERN void Settings_includeReferenceDateEvents(Settings *self,bool b){
            self->includeReferenceDateEvents() = b;
        }
SWIGINTERN void Settings_includeTodaysCashFlows(Settings *self,bool b){
            self->includeTodaysCashFlows() = b;
        }

using QuantLib::Statistics;
using QuantLib::IncrementalStatistics;
using QuantLib::RiskStatistics;
using QuantLib::GenericSequenceStatistics;

SWIGINTERN void Statistics_add__SWIG_2(Statistics *self,std::vector< Real > const &values){
            self->addSequence(values.begin(), values.end());
        }
SWIGINTERN void Statistics_add__SWIG_3(Statistics *self,std::vector< Real > const &values,std::vector< Real > const &weights){
            self->addSequence(values.begin(), values.end(), weights.begin());
        }
SWIGINTERN void IncrementalStatistics_add__SWIG_2(IncrementalStatistics *self,std::vector< Real > const &values){
            self->addSequence(values.begin(), values.end());
        }
SWIGINTERN void IncrementalStatistics_add__SWIG_3(IncrementalStatistics *self,std::vector< Real > const &values,std::vector< Real > const &weights){
            self->addSequence(values.begin(), values.end(), weights.begin());
        }

using QuantLib::CapFloorTermVolatilityStructure;

SWIGINTERN bool boost_shared_ptr_Sl_CapFloorTermVolatilityStructure_Sg__isNull(boost::shared_ptr< CapFloorTermVolatilityStructure > *self){
                return !(*self);
            }
SWIGINTERN boost::shared_ptr< Observable > boost_shared_ptr_Sl_CapFloorTermVolatilityStructure_Sg__asObservable(boost::shared_ptr< CapFloorTermVolatilityStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }
SWIGINTERN boost::shared_ptr< Observable > Handle_Sl_CapFloorTermVolatilityStructure_Sg__asObservable(Handle< CapFloorTermVolatilityStructure > *self){
        return boost::shared_ptr<Observable>(*self);
    }

using QuantLib::CapFloorTermVolCurve;
typedef boost::shared_ptr<CapFloorTermVolatilityStructure> CapFloorTermVolCurvePtr;

SWIGINTERN CapFloorTermVolCurvePtr *new_CapFloorTermVolCurvePtr__SWIG_0(Date const &referenceDate,Calendar const &calendar,BusinessDayConvention bdc,std::vector< Period > const &lengths,std::vector< Volatility > const &vols,DayCounter const &dc=QuantLib::Actual365Fixed()){
            return new CapFloorTermVolCurvePtr(
                new CapFloorTermVolCurve(referenceDate,calendar,bdc,
                                         lengths,vols,dc));
        }
SWIGINTERN CapFloorTermVolCurvePtr *new_CapFloorTermVolCurvePtr__SWIG_2(Natural settlementDays,Calendar const &calendar,BusinessDayConvention bdc,std::vector< Period > const &lengths,std::vector< Volatility > const &vols,DayCounter const &dc=QuantLib::Actual365Fixed()){
            return new CapFloorTermVolCurvePtr(
                new CapFloorTermVolCurve(settlementDays,calendar,bdc,
                                         lengths,vols,dc));
        }

using QuantLib::CapFloorTermVolSurface;
typedef boost::shared_ptr<CapFloorTermVolatilityStructure> CapFloorTermVolSurfacePtr;

SWIGINTERN CapFloorTermVolSurfacePtr *new_CapFloorTermVolSurfacePtr__SWIG_0(Natural settlementDays,Calendar const &calendar,BusinessDayConvention bdc,std::vector< Period > const &optionTenors,std::vector< Rate > const &strikes,std::vector< std::vector< Handle< Quote > > > const &quotes,DayCounter const &dc=QuantLib::Actual365Fixed()){
            return new CapFloorTermVolSurfacePtr(new CapFloorTermVolSurface(settlementDays, 
            calendar,
            bdc,
            optionTenors,
            strikes,
            quotes,
            dc));
        }
SWIGINTERN CapFloorTermVolSurfacePtr *new_CapFloorTermVolSurfacePtr__SWIG_2(Date const &settlementDate,Calendar const &calendar,BusinessDayConvention bdc,std::vector< Period > const &optionTenors,std::vector< Rate > const &strikes,std::vector< std::vector< Handle< Quote > > > const &quotes,DayCounter const &dc=QuantLib::Actual365Fixed()){
            return new CapFloorTermVolSurfacePtr(new CapFloorTermVolSurface(settlementDate, 
            calendar,
            bdc,
            optionTenors,
            strikes,
            quotes,
            dc));
        }
SWIGINTERN CapFloorTermVolSurfacePtr *new_CapFloorTermVolSurfacePtr__SWIG_4(Date const &settlementDate,Calendar const &calendar,BusinessDayConvention bdc,std::vector< Period > const &optionTenors,std::vector< Rate > const &strikes,Matrix const &volatilities,DayCounter const &dc=QuantLib::Actual365Fixed()){
            return new CapFloorTermVolSurfacePtr(new CapFloorTermVolSurface(settlementDate, 
            calendar,
            bdc,
            optionTenors,
            strikes,
            volatilities,
            dc));
        }
SWIGINTERN CapFloorTermVolSurfacePtr *new_CapFloorTermVolSurfacePtr__SWIG_6(Natural settlementDays,Calendar const &calendar,BusinessDayConvention bdc,std::vector< Period > const &optionTenors,std::vector< Rate > const &strikes,Matrix const &volatilities,DayCounter const &dc=QuantLib::Actual365Fixed()){ 
            return new CapFloorTermVolSurfacePtr(new CapFloorTermVolSurface(settlementDays, 
            calendar,
            bdc,
            optionTenors,
            strikes,
            volatilities,
            dc));
        }

using QuantLib::StrippedOptionletBase;
using QuantLib::VolatilityType;

SWIGINTERN bool boost_shared_ptr_Sl_StrippedOptionletBase_Sg__isNull(boost::shared_ptr< StrippedOptionletBase > *self){
                return !(*self);
            }

using QuantLib::OptionletStripper1;
typedef boost::shared_ptr<StrippedOptionletBase> OptionletStripper1Ptr;

SWIGINTERN OptionletStripper1Ptr *new_OptionletStripper1Ptr__SWIG_0(CapFloorTermVolSurfacePtr const &parVolSurface,IborIndexPtr const &index,Rate switchStrikes=Null< Rate >(),Real accuracy=1.0e-6,Natural maxIter=100,Handle< YieldTermStructure > const &discount=Handle< YieldTermStructure >(),VolatilityType type=ShiftedLognormal,Real displacement=0.0,bool dontThrow=false){
            boost::shared_ptr<CapFloorTermVolSurface> surface = 
                boost::dynamic_pointer_cast<CapFloorTermVolSurface>(parVolSurface);
            boost::shared_ptr<IborIndex> idx =
                boost::dynamic_pointer_cast<IborIndex>(index);
            return new OptionletStripper1Ptr(new OptionletStripper1(surface,
                                                                    idx,
                                                                    switchStrikes,
                                                                    accuracy,
                                                                    maxIter,
                                                                    discount,
                                                                    type,
                                                                    displacement,
                                                                    dontThrow));
        }
SWIGINTERN Matrix const &OptionletStripper1Ptr_capFloorPrices(OptionletStripper1Ptr const *self){
            return boost::dynamic_pointer_cast<OptionletStripper1>(*self)
                ->capFloorPrices();
        }
SWIGINTERN Matrix const &OptionletStripper1Ptr_capFloorVolatilities(OptionletStripper1Ptr const *self){
            return boost::dynamic_pointer_cast<OptionletStripper1>(*self)
                ->capFloorVolatilities();
        }
SWIGINTERN Matrix const &OptionletStripper1Ptr_optionletPrices(OptionletStripper1Ptr const *self){
            return boost::dynamic_pointer_cast<OptionletStripper1>(*self)
                ->optionletPrices();
        }
SWIGINTERN Rate OptionletStripper1Ptr_switchStrike(OptionletStripper1Ptr const *self){
            return boost::dynamic_pointer_cast<OptionletStripper1>(*self)
                ->switchStrike();
        }

using QuantLib::StrippedOptionletAdapter;
typedef boost::shared_ptr<OptionletVolatilityStructure>
   StrippedOptionletAdapterPtr;

SWIGINTERN StrippedOptionletAdapterPtr *new_StrippedOptionletAdapterPtr(boost::shared_ptr< StrippedOptionletBase > const &stripper){
            return new StrippedOptionletAdapterPtr(
                new StrippedOptionletAdapter(stripper));
        }

using QuantLib::Actual365Fixed;
using QuantLib::Swaption;
using QuantLib::NonstandardSwaption;
using QuantLib::Settlement;
using QuantLib::FloatFloatSwaption;
typedef boost::shared_ptr<Instrument> SwaptionPtr;
typedef boost::shared_ptr<Instrument> NonstandardSwaptionPtr;
typedef boost::shared_ptr<Instrument> FloatFloatSwaptionPtr;

SWIGINTERN SwaptionPtr *new_SwaptionPtr__SWIG_0(VanillaSwapPtr const &simpleSwap,boost::shared_ptr< Exercise > const &exercise,Settlement::Type type=Settlement::Physical){
            boost::shared_ptr<VanillaSwap> swap =
                 boost::dynamic_pointer_cast<VanillaSwap>(simpleSwap);
            QL_REQUIRE(swap, "simple swap required");
            return new SwaptionPtr(new Swaption(swap,exercise,type));
        }

using QuantLib::BasketGeneratingEngine;

SWIGINTERN NonstandardSwaptionPtr *new_NonstandardSwaptionPtr__SWIG_0(NonstandardSwapPtr const &nonstandardSwap,boost::shared_ptr< Exercise > const &exercise,Settlement::Type type=Settlement::Physical){
            boost::shared_ptr<NonstandardSwap> swap =
                 boost::dynamic_pointer_cast<NonstandardSwap>(nonstandardSwap);
            QL_REQUIRE(swap, "nonstandard swap required");
            return new NonstandardSwaptionPtr(new NonstandardSwaption(swap,exercise,type));
        }
SWIGINTERN std::vector< boost::shared_ptr< CalibrationHelper > > NonstandardSwaptionPtr_calibrationBasket(NonstandardSwaptionPtr *self,boost::shared_ptr< Index > standardSwapBase,boost::shared_ptr< SwaptionVolatilityStructure > swaptionVolatility,std::string typeStr){

            BasketGeneratingEngine::CalibrationBasketType type;
            if(typeStr == "Naive")
                type = BasketGeneratingEngine::Naive;
            else if(typeStr == "MaturityStrikeByDeltaGamma")
                type = BasketGeneratingEngine::MaturityStrikeByDeltaGamma;
            else
                QL_FAIL("type " << typeStr << "unknown.");
            boost::shared_ptr<SwapIndex> swapIndex =
                boost::dynamic_pointer_cast<SwapIndex>(standardSwapBase);
            return boost::dynamic_pointer_cast<NonstandardSwaption>(*self)->
                calibrationBasket(swapIndex, swaptionVolatility, type);
        }
SWIGINTERN FloatFloatSwaptionPtr *new_FloatFloatSwaptionPtr(FloatFloatSwapPtr const &simpleSwap,boost::shared_ptr< Exercise > const &exercise){
            boost::shared_ptr<FloatFloatSwap> swap =
                 boost::dynamic_pointer_cast<FloatFloatSwap>(simpleSwap);
            QL_REQUIRE(swap, "floatfloat swap required");
            return new FloatFloatSwaptionPtr(new FloatFloatSwaption(swap,exercise));
        }
SWIGINTERN std::vector< boost::shared_ptr< CalibrationHelper > > FloatFloatSwaptionPtr_calibrationBasket(FloatFloatSwaptionPtr *self,boost::shared_ptr< Index > standardSwapBase,boost::shared_ptr< SwaptionVolatilityStructure > swaptionVolatility,std::string typeStr){

            BasketGeneratingEngine::CalibrationBasketType type;
            if(typeStr == "Naive")
                type = BasketGeneratingEngine::Naive;
            else if(typeStr == "MaturityStrikeByDeltaGamma")
                type = BasketGeneratingEngine::MaturityStrikeByDeltaGamma;
            else
                QL_FAIL("type " << typeStr << "unknown.");
            boost::shared_ptr<SwapIndex> swapIndex =
                boost::dynamic_pointer_cast<SwapIndex>(standardSwapBase);
            return boost::dynamic_pointer_cast<FloatFloatSwaption>(*self)->
                calibrationBasket(swapIndex, swaptionVolatility, type);
        }
SWIGINTERN Real FloatFloatSwaptionPtr_underlyingValue(FloatFloatSwaptionPtr *self){
            return boost::dynamic_pointer_cast<FloatFloatSwaption>(*self)->result<Real>("underlyingValue");
        }

using QuantLib::BlackSwaptionEngine;
using QuantLib::BachelierSwaptionEngine;
typedef boost::shared_ptr<PricingEngine> BlackSwaptionEnginePtr;
typedef boost::shared_ptr<PricingEngine> BachelierSwaptionEnginePtr;

SWIGINTERN BlackSwaptionEnginePtr *new_BlackSwaptionEnginePtr__SWIG_0(Handle< YieldTermStructure > const &discountCurve,Handle< Quote > const &vol,DayCounter const &dc=Actual365Fixed(),Real displacement=0.0){
            return new BlackSwaptionEnginePtr(
                          new BlackSwaptionEngine(discountCurve, vol, dc, displacement));
        }
SWIGINTERN BlackSwaptionEnginePtr *new_BlackSwaptionEnginePtr__SWIG_3(Handle< YieldTermStructure > const &discountCurve,Handle< SwaptionVolatilityStructure > const &v){
            return new BlackSwaptionEnginePtr(
                                   new BlackSwaptionEngine(discountCurve, v));
        }
SWIGINTERN Real BlackSwaptionEnginePtr_vega(BlackSwaptionEnginePtr *self){
                return boost::dynamic_pointer_cast<Swaption>(*self)->result<Real>("vega");
        }
SWIGINTERN BachelierSwaptionEnginePtr *new_BachelierSwaptionEnginePtr__SWIG_0(Handle< YieldTermStructure > const &discountCurve,Handle< Quote > const &vol,DayCounter const &dc=Actual365Fixed()){
            return new BlackSwaptionEnginePtr(
                          new BachelierSwaptionEngine(discountCurve, vol, dc));
        }
SWIGINTERN BachelierSwaptionEnginePtr *new_BachelierSwaptionEnginePtr__SWIG_2(Handle< YieldTermStructure > const &discountCurve,Handle< SwaptionVolatilityStructure > const &v){
            return new BlackSwaptionEnginePtr(
                                   new BachelierSwaptionEngine(discountCurve, v));
        }


void enableTracing() { 
    QL_TRACE_ENABLE;
}

void disableTracing() {
    QL_TRACE_DISABLE;
}



using QuantLib::ConstantEstimator;
using QuantLib::SimpleLocalEstimator;
using QuantLib::GarmanKlassSigma1;
using QuantLib::ParkinsonSigma;
using QuantLib::GarmanKlassSigma3;
using QuantLib::GarmanKlassSigma4;
using QuantLib::GarmanKlassSigma5;
using QuantLib::GarmanKlassSigma6;


using QuantLib::InterpolatedZeroCurve;


typedef boost::shared_ptr<YieldTermStructure> ZeroCurvePtr;

SWIGINTERN ZeroCurvePtr *new_ZeroCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Rate > const &yields,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),Linear const &i=Linear(),Compounding compounding=Continuous,Frequency frequency=Annual){
            return new ZeroCurvePtr(
                new InterpolatedZeroCurve<Linear>(dates,yields,
                                                        dayCounter,
                                                        calendar,i,
                                                        compounding,
                                                        frequency));
        }
SWIGINTERN std::vector< Time > const &ZeroCurvePtr_times(ZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Linear> ZeroCurve;
            return boost::dynamic_pointer_cast<ZeroCurve>(*self)->times();
        }
SWIGINTERN std::vector< Real > const &ZeroCurvePtr_data(ZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Linear> ZeroCurve;
            return boost::dynamic_pointer_cast<ZeroCurve>(*self)->data();
        }
SWIGINTERN std::vector< Date > const &ZeroCurvePtr_dates(ZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Linear> ZeroCurve;
            return boost::dynamic_pointer_cast<ZeroCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Rate > const &ZeroCurvePtr_zeroRates(ZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Linear> ZeroCurve;
            return boost::dynamic_pointer_cast<ZeroCurve>(*self)->zeroRates();
        }
SWIGINTERN std::vector< std::pair< Date,Rate > > ZeroCurvePtr_nodes(ZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Linear> ZeroCurve;
            return boost::dynamic_pointer_cast<ZeroCurve>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> LogLinearZeroCurvePtr;

SWIGINTERN LogLinearZeroCurvePtr *new_LogLinearZeroCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Rate > const &yields,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),LogLinear const &i=LogLinear(),Compounding compounding=Continuous,Frequency frequency=Annual){
            return new LogLinearZeroCurvePtr(
                new InterpolatedZeroCurve<LogLinear>(dates,yields,
                                                        dayCounter,
                                                        calendar,i,
                                                        compounding,
                                                        frequency));
        }
SWIGINTERN std::vector< Time > const &LogLinearZeroCurvePtr_times(LogLinearZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<LogLinear> LogLinearZeroCurve;
            return boost::dynamic_pointer_cast<LogLinearZeroCurve>(*self)->times();
        }
SWIGINTERN std::vector< Real > const &LogLinearZeroCurvePtr_data(LogLinearZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<LogLinear> LogLinearZeroCurve;
            return boost::dynamic_pointer_cast<LogLinearZeroCurve>(*self)->data();
        }
SWIGINTERN std::vector< Date > const &LogLinearZeroCurvePtr_dates(LogLinearZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<LogLinear> LogLinearZeroCurve;
            return boost::dynamic_pointer_cast<LogLinearZeroCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Rate > const &LogLinearZeroCurvePtr_zeroRates(LogLinearZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<LogLinear> LogLinearZeroCurve;
            return boost::dynamic_pointer_cast<LogLinearZeroCurve>(*self)->zeroRates();
        }
SWIGINTERN std::vector< std::pair< Date,Rate > > LogLinearZeroCurvePtr_nodes(LogLinearZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<LogLinear> LogLinearZeroCurve;
            return boost::dynamic_pointer_cast<LogLinearZeroCurve>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> CubicZeroCurvePtr;

SWIGINTERN CubicZeroCurvePtr *new_CubicZeroCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Rate > const &yields,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),Cubic const &i=Cubic(),Compounding compounding=Continuous,Frequency frequency=Annual){
            return new CubicZeroCurvePtr(
                new InterpolatedZeroCurve<Cubic>(dates,yields,
                                                        dayCounter,
                                                        calendar,i,
                                                        compounding,
                                                        frequency));
        }
SWIGINTERN std::vector< Time > const &CubicZeroCurvePtr_times(CubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Cubic> CubicZeroCurve;
            return boost::dynamic_pointer_cast<CubicZeroCurve>(*self)->times();
        }
SWIGINTERN std::vector< Real > const &CubicZeroCurvePtr_data(CubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Cubic> CubicZeroCurve;
            return boost::dynamic_pointer_cast<CubicZeroCurve>(*self)->data();
        }
SWIGINTERN std::vector< Date > const &CubicZeroCurvePtr_dates(CubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Cubic> CubicZeroCurve;
            return boost::dynamic_pointer_cast<CubicZeroCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Rate > const &CubicZeroCurvePtr_zeroRates(CubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Cubic> CubicZeroCurve;
            return boost::dynamic_pointer_cast<CubicZeroCurve>(*self)->zeroRates();
        }
SWIGINTERN std::vector< std::pair< Date,Rate > > CubicZeroCurvePtr_nodes(CubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<Cubic> CubicZeroCurve;
            return boost::dynamic_pointer_cast<CubicZeroCurve>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> LogCubicZeroCurvePtr;

SWIGINTERN LogCubicZeroCurvePtr *new_LogCubicZeroCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Rate > const &yields,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),DefaultLogCubic const &i=DefaultLogCubic(),Compounding compounding=Continuous,Frequency frequency=Annual){
            return new LogCubicZeroCurvePtr(
                new InterpolatedZeroCurve<DefaultLogCubic>(dates,yields,
                                                        dayCounter,
                                                        calendar,i,
                                                        compounding,
                                                        frequency));
        }
SWIGINTERN std::vector< Time > const &LogCubicZeroCurvePtr_times(LogCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<DefaultLogCubic> LogCubicZeroCurve;
            return boost::dynamic_pointer_cast<LogCubicZeroCurve>(*self)->times();
        }
SWIGINTERN std::vector< Real > const &LogCubicZeroCurvePtr_data(LogCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<DefaultLogCubic> LogCubicZeroCurve;
            return boost::dynamic_pointer_cast<LogCubicZeroCurve>(*self)->data();
        }
SWIGINTERN std::vector< Date > const &LogCubicZeroCurvePtr_dates(LogCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<DefaultLogCubic> LogCubicZeroCurve;
            return boost::dynamic_pointer_cast<LogCubicZeroCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Rate > const &LogCubicZeroCurvePtr_zeroRates(LogCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<DefaultLogCubic> LogCubicZeroCurve;
            return boost::dynamic_pointer_cast<LogCubicZeroCurve>(*self)->zeroRates();
        }
SWIGINTERN std::vector< std::pair< Date,Rate > > LogCubicZeroCurvePtr_nodes(LogCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<DefaultLogCubic> LogCubicZeroCurve;
            return boost::dynamic_pointer_cast<LogCubicZeroCurve>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> ForwardFlatZeroCurvePtr;

SWIGINTERN ForwardFlatZeroCurvePtr *new_ForwardFlatZeroCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Rate > const &yields,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),ForwardFlat const &i=ForwardFlat(),Compounding compounding=Continuous,Frequency frequency=Annual){
            return new ForwardFlatZeroCurvePtr(
                new InterpolatedZeroCurve<ForwardFlat>(dates,yields,
                                                        dayCounter,
                                                        calendar,i,
                                                        compounding,
                                                        frequency));
        }
SWIGINTERN std::vector< Time > const &ForwardFlatZeroCurvePtr_times(ForwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<ForwardFlat> ForwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<ForwardFlatZeroCurve>(*self)->times();
        }
SWIGINTERN std::vector< Real > const &ForwardFlatZeroCurvePtr_data(ForwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<ForwardFlat> ForwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<ForwardFlatZeroCurve>(*self)->data();
        }
SWIGINTERN std::vector< Date > const &ForwardFlatZeroCurvePtr_dates(ForwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<ForwardFlat> ForwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<ForwardFlatZeroCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Rate > const &ForwardFlatZeroCurvePtr_zeroRates(ForwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<ForwardFlat> ForwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<ForwardFlatZeroCurve>(*self)->zeroRates();
        }
SWIGINTERN std::vector< std::pair< Date,Rate > > ForwardFlatZeroCurvePtr_nodes(ForwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<ForwardFlat> ForwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<ForwardFlatZeroCurve>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> BackwardFlatZeroCurvePtr;

SWIGINTERN BackwardFlatZeroCurvePtr *new_BackwardFlatZeroCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Rate > const &yields,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),BackwardFlat const &i=BackwardFlat(),Compounding compounding=Continuous,Frequency frequency=Annual){
            return new BackwardFlatZeroCurvePtr(
                new InterpolatedZeroCurve<BackwardFlat>(dates,yields,
                                                        dayCounter,
                                                        calendar,i,
                                                        compounding,
                                                        frequency));
        }
SWIGINTERN std::vector< Time > const &BackwardFlatZeroCurvePtr_times(BackwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<BackwardFlat> BackwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<BackwardFlatZeroCurve>(*self)->times();
        }
SWIGINTERN std::vector< Real > const &BackwardFlatZeroCurvePtr_data(BackwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<BackwardFlat> BackwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<BackwardFlatZeroCurve>(*self)->data();
        }
SWIGINTERN std::vector< Date > const &BackwardFlatZeroCurvePtr_dates(BackwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<BackwardFlat> BackwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<BackwardFlatZeroCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Rate > const &BackwardFlatZeroCurvePtr_zeroRates(BackwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<BackwardFlat> BackwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<BackwardFlatZeroCurve>(*self)->zeroRates();
        }
SWIGINTERN std::vector< std::pair< Date,Rate > > BackwardFlatZeroCurvePtr_nodes(BackwardFlatZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<BackwardFlat> BackwardFlatZeroCurve;
            return boost::dynamic_pointer_cast<BackwardFlatZeroCurve>(*self)->nodes();
        }

typedef boost::shared_ptr<YieldTermStructure> MonotonicCubicZeroCurvePtr;

SWIGINTERN MonotonicCubicZeroCurvePtr *new_MonotonicCubicZeroCurvePtr__SWIG_0(std::vector< Date > const &dates,std::vector< Rate > const &yields,DayCounter const &dayCounter,Calendar const &calendar=Calendar(),MonotonicCubic const &i=MonotonicCubic(),Compounding compounding=Continuous,Frequency frequency=Annual){
            return new MonotonicCubicZeroCurvePtr(
                new InterpolatedZeroCurve<MonotonicCubic>(dates,yields,
                                                        dayCounter,
                                                        calendar,i,
                                                        compounding,
                                                        frequency));
        }
SWIGINTERN std::vector< Time > const &MonotonicCubicZeroCurvePtr_times(MonotonicCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<MonotonicCubic> MonotonicCubicZeroCurve;
            return boost::dynamic_pointer_cast<MonotonicCubicZeroCurve>(*self)->times();
        }
SWIGINTERN std::vector< Real > const &MonotonicCubicZeroCurvePtr_data(MonotonicCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<MonotonicCubic> MonotonicCubicZeroCurve;
            return boost::dynamic_pointer_cast<MonotonicCubicZeroCurve>(*self)->data();
        }
SWIGINTERN std::vector< Date > const &MonotonicCubicZeroCurvePtr_dates(MonotonicCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<MonotonicCubic> MonotonicCubicZeroCurve;
            return boost::dynamic_pointer_cast<MonotonicCubicZeroCurve>(*self)->dates();
        }
SWIGINTERN std::vector< Rate > const &MonotonicCubicZeroCurvePtr_zeroRates(MonotonicCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<MonotonicCubic> MonotonicCubicZeroCurve;
            return boost::dynamic_pointer_cast<MonotonicCubicZeroCurve>(*self)->zeroRates();
        }
SWIGINTERN std::vector< std::pair< Date,Rate > > MonotonicCubicZeroCurvePtr_nodes(MonotonicCubicZeroCurvePtr *self){
            typedef InterpolatedZeroCurve<MonotonicCubic> MonotonicCubicZeroCurve;
            return boost::dynamic_pointer_cast<MonotonicCubicZeroCurve>(*self)->nodes();
        }

    ZeroCurvePtr as_zerocurve(const boost::shared_ptr<YieldTermStructure> & curve) {
        return boost::dynamic_pointer_cast<QuantLib::ZeroCurve>(curve);
    }


using QuantLib::Forward;
typedef boost::shared_ptr<Instrument> ForwardPtr;

SWIGINTERN Real ForwardPtr_forwardValue(ForwardPtr *self){
                return boost::dynamic_pointer_cast<Forward>(*self)
                    -> forwardValue();
            }
SWIGINTERN InterestRate ForwardPtr_impliedYield(ForwardPtr *self,Real underlyingSpotValue,Real forwardValue,Date settlementDate,Compounding compoundingConvention,DayCounter dayCounter){
                    return boost::dynamic_pointer_cast<Forward>(*self)
                        -> impliedYield(underlyingSpotValue, forwardValue,
                                        settlementDate, compoundingConvention, 
                                        dayCounter);
                }

using QuantLib::FixedRateBondForward;
using QuantLib::FixedRateBond;
using QuantLib::BusinessDayConvention;
using QuantLib::Position;
typedef boost::shared_ptr<Instrument> FixedRateBondForwardPtr;

SWIGINTERN FixedRateBondForwardPtr *new_FixedRateBondForwardPtr__SWIG_0(Date const &valueDate,Date const &maturityDate,Position::Type type,Real strike,Natural settlementDays,DayCounter const &dayCounter,Calendar const &calendar,BusinessDayConvention businessDayConvention,FixedRateBondPtr const &fixedBond,Handle< YieldTermStructure > const &discountCurve=Handle< YieldTermStructure >(),Handle< YieldTermStructure > const &incomeDiscountCurve=Handle< YieldTermStructure >()){
                const boost::shared_ptr<FixedRateBond>& fixedCouponBond = 
                    boost::dynamic_pointer_cast<FixedRateBond>(fixedBond);
                return new FixedRateBondForwardPtr(
                       new FixedRateBondForward(
                            valueDate, maturityDate, type, strike,
                            settlementDays, dayCounter, calendar,
                            businessDayConvention, fixedCouponBond,
                            discountCurve,  incomeDiscountCurve));
            }
SWIGINTERN Real FixedRateBondForwardPtr_forwardPrice(FixedRateBondForwardPtr *self){
                return boost::dynamic_pointer_cast<FixedRateBondForward>(*self)
                    -> forwardPrice();
            }
SWIGINTERN Real FixedRateBondForwardPtr_cleanForwardPrice(FixedRateBondForwardPtr *self){
                return boost::dynamic_pointer_cast<FixedRateBondForward>(*self)
                    -> cleanForwardPrice();
            }
SWIGINTERN Real FixedRateBondForwardPtr_spotIncome(FixedRateBondForwardPtr *self,Handle< YieldTermStructure > const &incomeDiscountCurve){
                return boost::dynamic_pointer_cast<FixedRateBondForward>(*self)
                    -> spotIncome(incomeDiscountCurve);
            }
SWIGINTERN Real FixedRateBondForwardPtr_spotValue(FixedRateBondForwardPtr *self){
                return boost::dynamic_pointer_cast<FixedRateBondForward>(*self)
                    -> spotValue();
            }


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

#include "quantlib_wrap.h"

SwigDirector_UnaryFunctionDelegate::SwigDirector_UnaryFunctionDelegate() : UnaryFunctionDelegate(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_UnaryFunctionDelegate::~SwigDirector_UnaryFunctionDelegate() {
  
}


Real SwigDirector_UnaryFunctionDelegate::value(Real x) const {
  Real c_result = SwigValueInit< Real >() ;
  double jresult = 0 ;
  double jx  ;
  
  if (!swig_callbackvalue) {
    return UnaryFunctionDelegate::value(x);
  } else {
    jx = x;
    jresult = (double) swig_callbackvalue(jx);
    c_result = (Real)jresult; 
  }
  return c_result;
}

void SwigDirector_UnaryFunctionDelegate::swig_connect_director(SWIG_Callback0_t callbackvalue) {
  swig_callbackvalue = callbackvalue;
}

void SwigDirector_UnaryFunctionDelegate::swig_init_callbacks() {
  swig_callbackvalue = 0;
}

SwigDirector_CostFunctionDelegate::SwigDirector_CostFunctionDelegate() : CostFunctionDelegate(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_CostFunctionDelegate::~SwigDirector_CostFunctionDelegate() {
  
}


Real SwigDirector_CostFunctionDelegate::value(Array const &x) const {
  Real c_result = SwigValueInit< Real >() ;
  double jresult = 0 ;
  void * jx = 0 ;
  
  if (!swig_callbackvalue) {
    return CostFunctionDelegate::value(x);
  } else {
    jx = (Array *) &x; 
    jresult = (double) swig_callbackvalue(jx);
    c_result = (Real)jresult; 
  }
  return c_result;
}

Array SwigDirector_CostFunctionDelegate::values(Array const &x) const {
  Array c_result ;
  void * jresult = 0 ;
  void * jx = 0 ;
  
  if (!swig_callbackvalues) {
    return CostFunctionDelegate::values(x);
  } else {
    jx = (Array *) &x; 
    jresult = (void *) swig_callbackvalues(jx);
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Array", 0);
      return c_result;
    }
    c_result = *(Array *)jresult; 
  }
  return c_result;
}

void SwigDirector_CostFunctionDelegate::swig_connect_director(SWIG_Callback0_t callbackvalue, SWIG_Callback1_t callbackvalues) {
  swig_callbackvalue = callbackvalue;
  swig_callbackvalues = callbackvalues;
}

void SwigDirector_CostFunctionDelegate::swig_init_callbacks() {
  swig_callbackvalue = 0;
  swig_callbackvalues = 0;
}


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Period__SWIG_0() {
  void * jresult ;
  Period *result = 0 ;
  
  {
    try {
      result = (Period *)new Period();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Period__SWIG_1(int jarg1, int jarg2) {
  void * jresult ;
  Integer arg1 ;
  TimeUnit arg2 ;
  Period *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (TimeUnit)jarg2; 
  {
    try {
      result = (Period *)new Period(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Period__SWIG_2(int jarg1) {
  void * jresult ;
  Frequency arg1 ;
  Period *result = 0 ;
  
  arg1 = (Frequency)jarg1; 
  {
    try {
      result = (Period *)new Period(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Period_length(void * jarg1) {
  int jresult ;
  Period *arg1 = (Period *) 0 ;
  Integer result;
  
  arg1 = (Period *)jarg1; 
  {
    try {
      result = (Integer)((Period const *)arg1)->length();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Period_units(void * jarg1) {
  int jresult ;
  Period *arg1 = (Period *) 0 ;
  TimeUnit result;
  
  arg1 = (Period *)jarg1; 
  {
    try {
      result = (TimeUnit)((Period const *)arg1)->units();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Period_frequency(void * jarg1) {
  int jresult ;
  Period *arg1 = (Period *) 0 ;
  Frequency result;
  
  arg1 = (Period *)jarg1; 
  {
    try {
      result = (Frequency)((Period const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Period__SWIG_3(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = (Period *)new_Period__SWIG_3((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Period___str__(void * jarg1) {
  char * jresult ;
  Period *arg1 = (Period *) 0 ;
  std::string result;
  
  arg1 = (Period *)jarg1; 
  {
    try {
      result = Period___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Period___repr__(void * jarg1) {
  char * jresult ;
  Period *arg1 = (Period *) 0 ;
  std::string result;
  
  arg1 = (Period *)jarg1; 
  {
    try {
      result = Period___repr__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Period(void * jarg1) {
  Period *arg1 = (Period *) 0 ;
  
  arg1 = (Period *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_Clear(void * jarg1) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_Add(void * jarg1, void * jarg2) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  Period *arg2 = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_PeriodVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::size_type result;
  
  arg1 = (std::vector< Period > *)jarg1; 
  {
    try {
      result = ((std::vector< Period > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_PeriodVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::size_type result;
  
  arg1 = (std::vector< Period > *)jarg1; 
  {
    try {
      result = ((std::vector< Period > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::size_type arg2 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (std::vector< Period >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PeriodVector__SWIG_0() {
  void * jresult ;
  std::vector< Period > *result = 0 ;
  
  {
    try {
      result = (std::vector< Period > *)new std::vector< Period >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PeriodVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< Period > *arg1 = 0 ;
  std::vector< Period > *result = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< Period > *)new std::vector< Period >((std::vector< Period > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PeriodVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< Period > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< Period > *)new_std_vector_Sl_Period_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PeriodVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  Period result;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_Period_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PeriodVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  Period *result = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (Period *) &std_vector_Sl_Period_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  Period *arg3 = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Period_Sg__setitem(arg1,arg2,(Period const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period > *arg2 = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_Period_Sg__AddRange(arg1,(std::vector< Period > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PeriodVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< Period > *result = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< Period > *)std_vector_Sl_Period_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  Period *arg3 = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Period_Sg__Insert(arg1,arg2,(Period const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  std::vector< Period > *arg3 = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Period_Sg__InsertRange(arg1,arg2,(std::vector< Period > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_Period_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Period_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PeriodVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  int arg2 ;
  std::vector< Period > *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Period > *)std_vector_Sl_Period_Sg__Repeat((Period const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  {
    try {
      std_vector_Sl_Period_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Period_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PeriodVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  int arg2 ;
  std::vector< Period > *arg3 = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Period_Sg__SetRange(arg1,arg2,(std::vector< Period > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PeriodVector(void * jarg1) {
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Date__SWIG_0() {
  void * jresult ;
  Date *result = 0 ;
  
  {
    try {
      result = (Date *)new Date();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Date__SWIG_1(int jarg1, int jarg2, int jarg3) {
  void * jresult ;
  Day arg1 ;
  Month arg2 ;
  Year arg3 ;
  Date *result = 0 ;
  
  arg1 = (Day)jarg1; 
  arg2 = (Month)jarg2; 
  arg3 = (Year)jarg3; 
  {
    try {
      result = (Date *)new Date(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Date__SWIG_2(int jarg1, int jarg2, int jarg3, int jarg4, int jarg5, int jarg6, int jarg7, int jarg8) {
  void * jresult ;
  Day arg1 ;
  Month arg2 ;
  Year arg3 ;
  Hour arg4 ;
  Minute arg5 ;
  Second arg6 ;
  Millisecond arg7 ;
  Microsecond arg8 ;
  Date *result = 0 ;
  
  arg1 = (Day)jarg1; 
  arg2 = (Month)jarg2; 
  arg3 = (Year)jarg3; 
  arg4 = (Hour)jarg4; 
  arg5 = (Minute)jarg5; 
  arg6 = (Second)jarg6; 
  arg7 = (Millisecond)jarg7; 
  arg8 = (Microsecond)jarg8; 
  {
    try {
      result = (Date *)new_Date__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Date__SWIG_3(int jarg1, int jarg2, int jarg3, int jarg4, int jarg5, int jarg6, int jarg7) {
  void * jresult ;
  Day arg1 ;
  Month arg2 ;
  Year arg3 ;
  Hour arg4 ;
  Minute arg5 ;
  Second arg6 ;
  Millisecond arg7 ;
  Date *result = 0 ;
  
  arg1 = (Day)jarg1; 
  arg2 = (Month)jarg2; 
  arg3 = (Year)jarg3; 
  arg4 = (Hour)jarg4; 
  arg5 = (Minute)jarg5; 
  arg6 = (Second)jarg6; 
  arg7 = (Millisecond)jarg7; 
  {
    try {
      result = (Date *)new_Date__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Date__SWIG_4(int jarg1, int jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
  void * jresult ;
  Day arg1 ;
  Month arg2 ;
  Year arg3 ;
  Hour arg4 ;
  Minute arg5 ;
  Second arg6 ;
  Date *result = 0 ;
  
  arg1 = (Day)jarg1; 
  arg2 = (Month)jarg2; 
  arg3 = (Year)jarg3; 
  arg4 = (Hour)jarg4; 
  arg5 = (Minute)jarg5; 
  arg6 = (Second)jarg6; 
  {
    try {
      result = (Date *)new_Date__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Date__SWIG_5(long jarg1) {
  void * jresult ;
  BigInteger arg1 ;
  Date *result = 0 ;
  
  arg1 = (BigInteger)jarg1; 
  {
    try {
      result = (Date *)new Date(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_weekday(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Weekday result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Weekday)((Date const *)arg1)->weekday();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_dayOfMonth(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Day result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Day)((Date const *)arg1)->dayOfMonth();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_dayOfYear(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Day result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Day)((Date const *)arg1)->dayOfYear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_month(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Month result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Month)((Date const *)arg1)->month();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_year(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Year result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Year)((Date const *)arg1)->year();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_hours(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Hour result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Hour)Date_hours(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_minutes(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Minute result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Minute)Date_minutes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_seconds(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Second result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Second)Date_seconds(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_milliseconds(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Millisecond result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Millisecond)Date_milliseconds(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_microseconds(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Microsecond result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Microsecond)Date_microseconds(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Date_fractionOfDay(void * jarg1) {
  double jresult ;
  Date *arg1 = (Date *) 0 ;
  Time result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Time)Date_fractionOfDay((Date const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Date_fractionOfSecond(void * jarg1) {
  double jresult ;
  Date *arg1 = (Date *) 0 ;
  Time result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Time)Date_fractionOfSecond((Date const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_Date_serialNumber(void * jarg1) {
  long jresult ;
  Date *arg1 = (Date *) 0 ;
  BigInteger result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (BigInteger)((Date const *)arg1)->serialNumber();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Date_isLeap(int jarg1) {
  unsigned int jresult ;
  Year arg1 ;
  bool result;
  
  arg1 = (Year)jarg1; 
  {
    try {
      result = (bool)Date::isLeap(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_minDate() {
  void * jresult ;
  Date result;
  
  {
    try {
      result = Date::minDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_maxDate() {
  void * jresult ;
  Date result;
  
  {
    try {
      result = Date::maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_todaysDate() {
  void * jresult ;
  Date result;
  
  {
    try {
      result = Date::todaysDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_localDateTime() {
  void * jresult ;
  Date result;
  
  {
    try {
      result = Date_localDateTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_universalDateTime() {
  void * jresult ;
  Date result;
  
  {
    try {
      result = Date_universalDateTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_endOfMonth(void * jarg1) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = Date::endOfMonth((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Date_isEndOfMonth(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = 0 ;
  bool result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)Date::isEndOfMonth((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_nextWeekday(void * jarg1, int jarg2) {
  void * jresult ;
  Date *arg1 = 0 ;
  Weekday arg2 ;
  Date result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Weekday)jarg2; 
  {
    try {
      result = Date::nextWeekday((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_nthWeekday(unsigned long jarg1, int jarg2, int jarg3, int jarg4) {
  void * jresult ;
  Size arg1 ;
  Weekday arg2 ;
  Month arg3 ;
  Year arg4 ;
  Date result;
  
  arg1 = (Size)jarg1; 
  arg2 = (Weekday)jarg2; 
  arg3 = (Month)jarg3; 
  arg4 = (Year)jarg4; 
  {
    try {
      result = Date::nthWeekday(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_Add__SWIG_0(void * jarg1, long jarg2) {
  void * jresult ;
  Date *arg1 = (Date *) 0 ;
  BigInteger arg2 ;
  Date result;
  
  arg1 = (Date *)jarg1; 
  arg2 = (BigInteger)jarg2; 
  {
    try {
      result = ((Date const *)arg1)->operator +(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_Subtract__SWIG_0(void * jarg1, long jarg2) {
  void * jresult ;
  Date *arg1 = (Date *) 0 ;
  BigInteger arg2 ;
  Date result;
  
  arg1 = (Date *)jarg1; 
  arg2 = (BigInteger)jarg2; 
  {
    try {
      result = ((Date const *)arg1)->operator -(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_Add__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Date *arg1 = (Date *) 0 ;
  Period *arg2 = 0 ;
  Date result;
  
  arg1 = (Date *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Date const *)arg1)->operator +((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Date_Subtract__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Date *arg1 = (Date *) 0 ;
  Period *arg2 = 0 ;
  Date result;
  
  arg1 = (Date *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Date const *)arg1)->operator -((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Date__SWIG_6(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  Date *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  {
    try {
      result = (Date *)new_Date__SWIG_6((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Date_weekdayNumber(void * jarg1) {
  int jresult ;
  Date *arg1 = (Date *) 0 ;
  Integer result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = (Integer)Date_weekdayNumber(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Date___str__(void * jarg1) {
  char * jresult ;
  Date *arg1 = (Date *) 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = Date___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Date___repr__(void * jarg1) {
  char * jresult ;
  Date *arg1 = (Date *) 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = Date___repr__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Date_ISO(void * jarg1) {
  char * jresult ;
  Date *arg1 = (Date *) 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      result = Date_ISO(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Date(void * jarg1) {
  Date *arg1 = (Date *) 0 ;
  
  arg1 = (Date *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateParser_parseFormatted(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = DateParser::parseFormatted((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateParser_parseISO(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = DateParser::parseISO((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateParser_parse(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  {
    try {
      result = DateParser_parse((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DateParser() {
  void * jresult ;
  DateParser *result = 0 ;
  
  {
    try {
      result = (DateParser *)new DateParser();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DateParser(void * jarg1) {
  DateParser *arg1 = (DateParser *) 0 ;
  
  arg1 = (DateParser *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PeriodParser_parse(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = PeriodParser::parse((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PeriodParser() {
  void * jresult ;
  PeriodParser *result = 0 ;
  
  {
    try {
      result = (PeriodParser *)new PeriodParser();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PeriodParser(void * jarg1) {
  PeriodParser *arg1 = (PeriodParser *) 0 ;
  
  arg1 = (PeriodParser *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_Clear(void * jarg1) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_Add(void * jarg1, void * jarg2) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  Date *arg2 = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_DateVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::size_type result;
  
  arg1 = (std::vector< Date > *)jarg1; 
  {
    try {
      result = ((std::vector< Date > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_DateVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::size_type result;
  
  arg1 = (std::vector< Date > *)jarg1; 
  {
    try {
      result = ((std::vector< Date > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::size_type arg2 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (std::vector< Date >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DateVector__SWIG_0() {
  void * jresult ;
  std::vector< Date > *result = 0 ;
  
  {
    try {
      result = (std::vector< Date > *)new std::vector< Date >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DateVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< Date > *)new std::vector< Date >((std::vector< Date > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DateVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< Date > *)new_std_vector_Sl_Date_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  Date result;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_Date_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  Date *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (Date *) &std_vector_Sl_Date_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  Date *arg3 = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Date_Sg__setitem(arg1,arg2,(Date const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date > *arg2 = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_Date_Sg__AddRange(arg1,(std::vector< Date > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< Date > *)std_vector_Sl_Date_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  Date *arg3 = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Date_Sg__Insert(arg1,arg2,(Date const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  std::vector< Date > *arg3 = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Date_Sg__InsertRange(arg1,arg2,(std::vector< Date > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_Date_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Date_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  Date *arg1 = 0 ;
  int arg2 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Date > *)std_vector_Sl_Date_Sg__Repeat((Date const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  {
    try {
      std_vector_Sl_Date_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Date_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DateVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  int arg2 ;
  std::vector< Date > *arg3 = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Date_Sg__SetRange(arg1,arg2,(std::vector< Date > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DateVector(void * jarg1) {
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IMM_isIMMdate__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  Date *arg1 = 0 ;
  bool arg2 ;
  bool result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (bool)IMM::isIMMdate((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IMM_isIMMdate__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = 0 ;
  bool result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)IMM::isIMMdate((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IMM_isIMMcode__SWIG_0(char * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  bool result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (bool)IMM::isIMMcode((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IMM_isIMMcode__SWIG_1(char * jarg1) {
  unsigned int jresult ;
  std::string *arg1 = 0 ;
  bool result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = (bool)IMM::isIMMcode((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_IMM_code(void * jarg1) {
  char * jresult ;
  Date *arg1 = 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = IMM::code((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_date__SWIG_0(char * jarg1, void * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = IMM::date((std::string const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_date__SWIG_1(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = IMM::date((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Date *arg1 = 0 ;
  bool arg2 ;
  Date result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = IMM::nextDate((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_1(void * jarg1) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = IMM::nextDate((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_2() {
  void * jresult ;
  Date result;
  
  {
    try {
      result = IMM::nextDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_3(char * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = IMM::nextDate((std::string const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_4(char * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = IMM::nextDate((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_5(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = IMM::nextDate((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_0(void * jarg1, unsigned int jarg2) {
  char * jresult ;
  Date *arg1 = 0 ;
  bool arg2 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = IMM::nextCode((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_1(void * jarg1) {
  char * jresult ;
  Date *arg1 = 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = IMM::nextCode((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_2() {
  char * jresult ;
  std::string result;
  
  {
    try {
      result = IMM::nextCode();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_3(char * jarg1, unsigned int jarg2, void * jarg3) {
  char * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = IMM::nextCode((std::string const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_4(char * jarg1, unsigned int jarg2) {
  char * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = IMM::nextCode((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_5(char * jarg1) {
  char * jresult ;
  std::string *arg1 = 0 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = IMM::nextCode((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IMM() {
  void * jresult ;
  IMM *result = 0 ;
  
  {
    try {
      result = (IMM *)new IMM();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IMM(void * jarg1) {
  IMM *arg1 = (IMM *) 0 ;
  
  arg1 = (IMM *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ASX_isASXdate__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  Date *arg1 = 0 ;
  bool arg2 ;
  bool result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (bool)ASX::isASXdate((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ASX_isASXdate__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = 0 ;
  bool result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)ASX::isASXdate((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ASX_isASXcode__SWIG_0(char * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  bool result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (bool)ASX::isASXcode((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ASX_isASXcode__SWIG_1(char * jarg1) {
  unsigned int jresult ;
  std::string *arg1 = 0 ;
  bool result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = (bool)ASX::isASXcode((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_ASX_code(void * jarg1) {
  char * jresult ;
  Date *arg1 = 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ASX::code((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_date__SWIG_0(char * jarg1, void * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ASX::date((std::string const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_date__SWIG_1(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = ASX::date((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Date *arg1 = 0 ;
  bool arg2 ;
  Date result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = ASX::nextDate((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_1(void * jarg1) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ASX::nextDate((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_2() {
  void * jresult ;
  Date result;
  
  {
    try {
      result = ASX::nextDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_3(char * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ASX::nextDate((std::string const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_4(char * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = ASX::nextDate((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_5(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Date result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = ASX::nextDate((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_0(void * jarg1, unsigned int jarg2) {
  char * jresult ;
  Date *arg1 = 0 ;
  bool arg2 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = ASX::nextCode((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_1(void * jarg1) {
  char * jresult ;
  Date *arg1 = 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ASX::nextCode((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_2() {
  char * jresult ;
  std::string result;
  
  {
    try {
      result = ASX::nextCode();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_3(char * jarg1, unsigned int jarg2, void * jarg3) {
  char * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ASX::nextCode((std::string const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_4(char * jarg1, unsigned int jarg2) {
  char * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = ASX::nextCode((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_5(char * jarg1) {
  char * jresult ;
  std::string *arg1 = 0 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = ASX::nextCode((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ASX() {
  void * jresult ;
  ASX *result = 0 ;
  
  {
    try {
      result = (ASX *)new ASX();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ASX(void * jarg1) {
  ASX *arg1 = (ASX *) 0 ;
  
  arg1 = (ASX *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_Clear(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_Add(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      (arg1)->push_back((int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_IntVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int > *)jarg1; 
  {
    try {
      result = ((std::vector< int > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_IntVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int > *)jarg1; 
  {
    try {
      result = ((std::vector< int > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntVector__SWIG_0() {
  void * jresult ;
  std::vector< int > *result = 0 ;
  
  {
    try {
      result = (std::vector< int > *)new std::vector< int >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< int > *arg1 = 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< int > *)new_std_vector_Sl_int_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_IntVector_getitemcopy(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (int)std_vector_Sl_int_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_IntVector_getitem(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (int *) &std_vector_Sl_int_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_setitem(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__setitem(arg1,arg2,(int const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_int_Sg__AddRange(arg1,(std::vector< int > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< int > *)std_vector_Sl_int_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_Insert(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__Insert(arg1,arg2,(int const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_int_Sg__InsertRange(arg1,arg2,(std::vector< int > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntVector_Repeat(int jarg1, int jarg2) {
  void * jresult ;
  int *arg1 = 0 ;
  int arg2 ;
  int temp1 ;
  std::vector< int > *result = 0 ;
  
  temp1 = (int)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< int > *)std_vector_Sl_int_Sg__Repeat((int const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  {
    try {
      std_vector_Sl_int_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_int_Sg__SetRange(arg1,arg2,(std::vector< int > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IntVector_Contains(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_vector_Sl_int_Sg__Contains(arg1,(int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_IntVector_IndexOf(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (int)std_vector_Sl_int_Sg__IndexOf(arg1,(int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_IntVector_LastIndexOf(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (int)std_vector_Sl_int_Sg__LastIndexOf(arg1,(int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IntVector_Remove(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_vector_Sl_int_Sg__Remove(arg1,(int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IntVector(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_Clear(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_Add(void * jarg1, unsigned int jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      (arg1)->push_back((unsigned int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type result;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type result;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (std::vector< unsigned int >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnsignedIntVector__SWIG_0() {
  void * jresult ;
  std::vector< unsigned int > *result = 0 ;
  
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnsignedIntVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnsignedIntVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_getitemcopy(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  unsigned int result;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_getitem(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  unsigned int *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  unsigned int *arg3 = 0 ;
  unsigned int temp3 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (unsigned int)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  unsigned int *arg3 = 0 ;
  unsigned int temp3 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (unsigned int)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  std::vector< unsigned int > *arg3 = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_Repeat(unsigned int jarg1, int jarg2) {
  void * jresult ;
  unsigned int *arg1 = 0 ;
  int arg2 ;
  unsigned int temp1 ;
  std::vector< unsigned int > *result = 0 ;
  
  temp1 = (unsigned int)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  {
    try {
      std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  int arg2 ;
  std::vector< unsigned int > *arg3 = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_Contains(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  bool result;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_IndexOf(void * jarg1, unsigned int jarg2) {
  int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  int result;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_LastIndexOf(void * jarg1, unsigned int jarg2) {
  int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  int result;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_UnsignedIntVector_Remove(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  bool result;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UnsignedIntVector(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_Clear(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_Add(void * jarg1, double jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  {
    try {
      (arg1)->push_back((double const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_DoubleVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type result;
  
  arg1 = (std::vector< double > *)jarg1; 
  {
    try {
      result = ((std::vector< double > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_DoubleVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type result;
  
  arg1 = (std::vector< double > *)jarg1; 
  {
    try {
      result = ((std::vector< double > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (std::vector< double >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DoubleVector__SWIG_0() {
  void * jresult ;
  std::vector< double > *result = 0 ;
  
  {
    try {
      result = (std::vector< double > *)new std::vector< double >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DoubleVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *result = 0 ;
  
  arg1 = (std::vector< double > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DoubleVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< double > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< double > *)new_std_vector_Sl_double_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleVector_getitemcopy(void * jarg1, int jarg2) {
  double jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  double result;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (double)std_vector_Sl_double_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleVector_getitem(void * jarg1, int jarg2) {
  double jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  double *result = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (double *) &std_vector_Sl_double_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_setitem(void * jarg1, int jarg2, double jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  double temp3 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (double)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_double_Sg__setitem(arg1,arg2,(double const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double > *arg2 = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (std::vector< double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_double_Sg__AddRange(arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DoubleVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< double > *result = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< double > *)std_vector_Sl_double_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_Insert(void * jarg1, int jarg2, double jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  double temp3 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (double)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_double_Sg__Insert(arg1,arg2,(double const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  std::vector< double > *arg3 = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_double_Sg__InsertRange(arg1,arg2,(std::vector< double > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_double_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_double_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DoubleVector_Repeat(double jarg1, int jarg2) {
  void * jresult ;
  double *arg1 = 0 ;
  int arg2 ;
  double temp1 ;
  std::vector< double > *result = 0 ;
  
  temp1 = (double)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< double > *)std_vector_Sl_double_Sg__Repeat((double const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  {
    try {
      std_vector_Sl_double_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_double_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoubleVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  std::vector< double > *arg3 = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_double_Sg__SetRange(arg1,arg2,(std::vector< double > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DoubleVector_Contains(void * jarg1, double jarg2) {
  unsigned int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  bool result;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_vector_Sl_double_Sg__Contains(arg1,(double const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DoubleVector_IndexOf(void * jarg1, double jarg2) {
  int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  int result;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (int)std_vector_Sl_double_Sg__IndexOf(arg1,(double const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DoubleVector_LastIndexOf(void * jarg1, double jarg2) {
  int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  int result;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (int)std_vector_Sl_double_Sg__LastIndexOf(arg1,(double const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DoubleVector_Remove(void * jarg1, double jarg2) {
  unsigned int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  bool result;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_vector_Sl_double_Sg__Remove(arg1,(double const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DoubleVector(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_Clear(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_Add(void * jarg1, char * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->push_back((std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_StrVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_StrVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (std::vector< std::string >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StrVector__SWIG_0() {
  void * jresult ;
  std::vector< std::string > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StrVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StrVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::string > *)new_std_vector_Sl_std_string_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_StrVector_getitemcopy(void * jarg1, int jarg2) {
  char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_string_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_StrVector_getitem(void * jarg1, int jarg2) {
  char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::string *) &std_vector_Sl_std_string_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_setitem(void * jarg1, int jarg2, char * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__setitem(arg1,arg2,(std::string const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_string_Sg__AddRange(arg1,(std::vector< std::string > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::string > *)std_vector_Sl_std_string_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_Insert(void * jarg1, int jarg2, char * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__Insert(arg1,arg2,(std::string const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__InsertRange(arg1,arg2,(std::vector< std::string > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrVector_Repeat(char * jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  std::vector< std::string > *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::string > *)std_vector_Sl_std_string_Sg__Repeat((std::string const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  {
    try {
      std_vector_Sl_std_string_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StrVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__SetRange(arg1,arg2,(std::vector< std::string > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_StrVector_Contains(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (bool)std_vector_Sl_std_string_Sg__Contains(arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_StrVector_IndexOf(void * jarg1, char * jarg2) {
  int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (int)std_vector_Sl_std_string_Sg__IndexOf(arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_StrVector_LastIndexOf(void * jarg1, char * jarg2) {
  int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (int)std_vector_Sl_std_string_Sg__LastIndexOf(arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_StrVector_Remove(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (bool)std_vector_Sl_std_string_Sg__Remove(arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StrVector(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_Clear(void * jarg1) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_Add(void * jarg1, unsigned int jarg2) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  bool *arg2 = 0 ;
  bool temp2 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  {
    try {
      (arg1)->push_back((bool const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_BoolVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type result;
  
  arg1 = (std::vector< bool > *)jarg1; 
  {
    try {
      result = ((std::vector< bool > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_BoolVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type result;
  
  arg1 = (std::vector< bool > *)jarg1; 
  {
    try {
      result = ((std::vector< bool > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (std::vector< bool >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BoolVector__SWIG_0() {
  void * jresult ;
  std::vector< bool > *result = 0 ;
  
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BoolVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< bool > *arg1 = 0 ;
  std::vector< bool > *result = 0 ;
  
  arg1 = (std::vector< bool > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >((std::vector< bool > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BoolVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< bool > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< bool > *)new_std_vector_Sl_bool_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BoolVector_getitemcopy(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  bool result;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (bool)std_vector_Sl_bool_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BoolVector_getitem(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  bool result;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (bool)std_vector_Sl_bool_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  bool *arg3 = 0 ;
  bool temp3 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = jarg3 ? true : false; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__setitem(arg1,arg2,(bool const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool > *arg2 = 0 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (std::vector< bool > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_bool_Sg__AddRange(arg1,(std::vector< bool > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BoolVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< bool > *result = 0 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< bool > *)std_vector_Sl_bool_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  bool *arg3 = 0 ;
  bool temp3 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = jarg3 ? true : false; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__Insert(arg1,arg2,(bool const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  std::vector< bool > *arg3 = 0 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< bool > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__InsertRange(arg1,arg2,(std::vector< bool > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BoolVector_Repeat(unsigned int jarg1, int jarg2) {
  void * jresult ;
  bool *arg1 = 0 ;
  int arg2 ;
  bool temp1 ;
  std::vector< bool > *result = 0 ;
  
  temp1 = jarg1 ? true : false; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< bool > *)std_vector_Sl_bool_Sg__Repeat((bool const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  {
    try {
      std_vector_Sl_bool_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BoolVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  int arg2 ;
  std::vector< bool > *arg3 = 0 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< bool > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__SetRange(arg1,arg2,(std::vector< bool > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BoolVector_Contains(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  bool *arg2 = 0 ;
  bool temp2 ;
  bool result;
  
  arg1 = (std::vector< bool > *)jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_vector_Sl_bool_Sg__Contains(arg1,(bool const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_BoolVector_IndexOf(void * jarg1, unsigned int jarg2) {
  int jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  bool *arg2 = 0 ;
  bool temp2 ;
  int result;
  
  arg1 = (std::vector< bool > *)jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  {
    try {
      result = (int)std_vector_Sl_bool_Sg__IndexOf(arg1,(bool const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_BoolVector_LastIndexOf(void * jarg1, unsigned int jarg2) {
  int jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  bool *arg2 = 0 ;
  bool temp2 ;
  int result;
  
  arg1 = (std::vector< bool > *)jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  {
    try {
      result = (int)std_vector_Sl_bool_Sg__LastIndexOf(arg1,(bool const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BoolVector_Remove(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  bool *arg2 = 0 ;
  bool temp2 ;
  bool result;
  
  arg1 = (std::vector< bool > *)jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_vector_Sl_bool_Sg__Remove(arg1,(bool const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BoolVector(void * jarg1) {
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  
  arg1 = (std::vector< bool > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NodePair__SWIG_0() {
  void * jresult ;
  std::pair< Date,double > *result = 0 ;
  
  {
    try {
      result = (std::pair< Date,double > *)new std::pair< Date,double >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NodePair__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  Date arg1 ;
  double arg2 ;
  Date *argp1 ;
  std::pair< Date,double > *result = 0 ;
  
  argp1 = (Date *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (double)jarg2; 
  {
    try {
      result = (std::pair< Date,double > *)new std::pair< Date,double >(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NodePair__SWIG_2(void * jarg1) {
  void * jresult ;
  std::pair< Date,double > *arg1 = 0 ;
  std::pair< Date,double > *result = 0 ;
  
  arg1 = (std::pair< Date,double > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::pair< Date,double > *)new std::pair< Date,double >((std::pair< Date,double > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodePair_first_set(void * jarg1, void * jarg2) {
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  
  arg1 = (std::pair< Date,double > *)jarg1; 
  arg2 = (Date *)jarg2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NodePair_first_get(void * jarg1) {
  void * jresult ;
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  Date *result = 0 ;
  
  arg1 = (std::pair< Date,double > *)jarg1; 
  result = (Date *)& ((arg1)->first);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodePair_second_set(void * jarg1, double jarg2) {
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  double arg2 ;
  
  arg1 = (std::pair< Date,double > *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->second = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NodePair_second_get(void * jarg1) {
  double jresult ;
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  double result;
  
  arg1 = (std::pair< Date,double > *)jarg1; 
  result = (double) ((arg1)->second);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NodePair(void * jarg1) {
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  
  arg1 = (std::pair< Date,double > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_Clear(void * jarg1) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::pair< Date,double > *arg2 = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (std::pair< Date,double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::pair< Date,double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_NodeVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::size_type result;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::pair< Date,double > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_NodeVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::size_type result;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::pair< Date,double > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::size_type arg2 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (std::vector< std::pair< Date,double > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NodeVector__SWIG_0() {
  void * jresult ;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::pair< Date,double > > *)new std::vector< std::pair< Date,double > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NodeVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::pair< Date,double > > *arg1 = 0 ;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< Date,double > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< Date,double > > *)new std::vector< std::pair< Date,double > >((std::vector< std::pair< Date,double > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NodeVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::pair< Date,double > > *)new_std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NodeVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  std::pair< Date,double > result;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::pair< Date,double >((const std::pair< Date,double > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NodeVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  std::pair< Date,double > *result = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::pair< Date,double > *) &std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  std::pair< Date,double > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::pair< Date,double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__setitem(arg1,arg2,(std::pair< Date,double > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (std::vector< std::pair< Date,double > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< Date,double > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__AddRange(arg1,(std::vector< std::pair< Date,double > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NodeVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::pair< Date,double > > *)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  std::pair< Date,double > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::pair< Date,double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Insert(arg1,arg2,(std::pair< Date,double > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< Date,double > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::pair< Date,double > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< Date,double > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::pair< Date,double > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NodeVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::pair< Date,double > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  arg1 = (std::pair< Date,double > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< Date,double > > *)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Repeat((std::pair< Date,double > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NodeVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< Date,double > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::pair< Date,double > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< Date,double > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< Date,double > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_NodeVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::pair< Date,double > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (std::pair< Date,double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Contains(arg1,(std::pair< Date,double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_NodeVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::pair< Date,double > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (std::pair< Date,double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__IndexOf(arg1,(std::pair< Date,double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_NodeVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::pair< Date,double > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (std::pair< Date,double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__LastIndexOf(arg1,(std::pair< Date,double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_NodeVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::pair< Date,double > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (std::pair< Date,double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,double > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__Remove(arg1,(std::pair< Date,double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NodeVector(void * jarg1) {
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib__Exercise_type(void * jarg1) {
  int jresult ;
  Exercise *arg1 = (Exercise *) 0 ;
  Exercise::Type result;
  
  arg1 = (Exercise *)jarg1; 
  {
    try {
      result = (Exercise::Type)((Exercise const *)arg1)->type();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib__Exercise_dates(void * jarg1) {
  void * jresult ;
  Exercise *arg1 = (Exercise *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (Exercise *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &((Exercise const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib__Exercise_lastDate(void * jarg1) {
  void * jresult ;
  Exercise *arg1 = (Exercise *) 0 ;
  Date result;
  
  arg1 = (Exercise *)jarg1; 
  {
    try {
      result = ((Exercise const *)arg1)->lastDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__Exercise(void * jarg1) {
  Exercise *arg1 = (Exercise *) 0 ;
  
  arg1 = (Exercise *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Exercise___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = (boost::shared_ptr< Exercise > *) 0 ;
  Exercise *result = 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1; 
  {
    try {
      result = (Exercise *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Exercise_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Exercise > *arg1 = (boost::shared_ptr< Exercise > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Exercise_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Exercise_American_get() {
  int jresult ;
  enum Exercise::Type result;
  
  result = (enum Exercise::Type)Exercise::American;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Exercise_Bermudan_get() {
  int jresult ;
  enum Exercise::Type result;
  
  result = (enum Exercise::Type)Exercise::Bermudan;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Exercise_European_get() {
  int jresult ;
  enum Exercise::Type result;
  
  result = (enum Exercise::Type)Exercise::European;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Exercise_exerciseType(void * jarg1) {
  int jresult ;
  boost::shared_ptr< Exercise > *arg1 = (boost::shared_ptr< Exercise > *) 0 ;
  Exercise::Type result;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1; 
  {
    try {
      result = (Exercise::Type)boost_shared_ptr_Sl_Exercise_Sg__exerciseType(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Exercise() {
  void * jresult ;
  boost::shared_ptr< Exercise > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Exercise > *)new boost::shared_ptr< Exercise >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Exercise(void * jarg1) {
  boost::shared_ptr< Exercise > *arg1 = (boost::shared_ptr< Exercise > *) 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Exercise_type(void * jarg1) {
  int jresult ;
  boost::shared_ptr< Exercise > *arg1 = (boost::shared_ptr< Exercise > *) 0 ;
  Exercise::Type result;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1; 
  {
    try {
      result = (Exercise::Type)(*arg1)->type();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Exercise_dates(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = (boost::shared_ptr< Exercise > *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &(*arg1)->dates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Exercise_lastDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = (boost::shared_ptr< Exercise > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1; 
  {
    try {
      result = (*arg1)->lastDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuropeanExercise(void * jarg1) {
  void * jresult ;
  Date *arg1 = 0 ;
  EuropeanExercisePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuropeanExercisePtr *)new_EuropeanExercisePtr((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuropeanExercise(void * jarg1) {
  EuropeanExercisePtr *arg1 = (EuropeanExercisePtr *) 0 ;
  
  arg1 = (EuropeanExercisePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmericanExercise__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  AmericanExercisePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (AmericanExercisePtr *)new_AmericanExercisePtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmericanExercise__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  AmericanExercisePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmericanExercisePtr *)new_AmericanExercisePtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AmericanExercise(void * jarg1) {
  AmericanExercisePtr *arg1 = (AmericanExercisePtr *) 0 ;
  
  arg1 = (AmericanExercisePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BermudanExercise__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  bool arg2 ;
  BermudanExercisePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (BermudanExercisePtr *)new_BermudanExercisePtr__SWIG_0((std::vector< Date > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BermudanExercise__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  BermudanExercisePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BermudanExercisePtr *)new_BermudanExercisePtr__SWIG_0((std::vector< Date > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BermudanExercise(void * jarg1) {
  BermudanExercisePtr *arg1 = (BermudanExercisePtr *) 0 ;
  
  arg1 = (BermudanExercisePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RebatedExercise__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  boost::shared_ptr< Exercise > arg1 ;
  std::vector< Real > arg2 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  boost::shared_ptr< Exercise > const *argp1 ;
  std::vector< Real > const *argp2 ;
  RebatedExercisePtr *result = 0 ;
  
  argp1 = (boost::shared_ptr< Exercise > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Exercise > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = (RebatedExercisePtr *)new_RebatedExercisePtr__SWIG_0(arg1,arg2,arg3,(Calendar const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RebatedExercise__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  boost::shared_ptr< Exercise > arg1 ;
  std::vector< Real > arg2 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  boost::shared_ptr< Exercise > const *argp1 ;
  std::vector< Real > const *argp2 ;
  RebatedExercisePtr *result = 0 ;
  
  argp1 = (boost::shared_ptr< Exercise > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Exercise > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RebatedExercisePtr *)new_RebatedExercisePtr__SWIG_0(arg1,arg2,arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RebatedExercise__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  boost::shared_ptr< Exercise > arg1 ;
  std::vector< Real > arg2 ;
  Natural arg3 ;
  boost::shared_ptr< Exercise > const *argp1 ;
  std::vector< Real > const *argp2 ;
  RebatedExercisePtr *result = 0 ;
  
  argp1 = (boost::shared_ptr< Exercise > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Exercise > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Natural)jarg3; 
  {
    try {
      result = (RebatedExercisePtr *)new_RebatedExercisePtr__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RebatedExercise__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< Exercise > arg1 ;
  std::vector< Real > arg2 ;
  boost::shared_ptr< Exercise > const *argp1 ;
  std::vector< Real > const *argp2 ;
  RebatedExercisePtr *result = 0 ;
  
  argp1 = (boost::shared_ptr< Exercise > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Exercise > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (RebatedExercisePtr *)new_RebatedExercisePtr__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RebatedExercise(void * jarg1) {
  RebatedExercisePtr *arg1 = (RebatedExercisePtr *) 0 ;
  
  arg1 = (RebatedExercisePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Observable___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Observable > *arg1 = (boost::shared_ptr< Observable > *) 0 ;
  Observable *result = 0 ;
  
  arg1 = (boost::shared_ptr< Observable > *)jarg1; 
  {
    try {
      result = (Observable *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Observable_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Observable > *arg1 = (boost::shared_ptr< Observable > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Observable > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Observable_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Observable() {
  void * jresult ;
  boost::shared_ptr< Observable > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Observable > *)new boost::shared_ptr< Observable >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Observable(void * jarg1) {
  boost::shared_ptr< Observable > *arg1 = (boost::shared_ptr< Observable > *) 0 ;
  
  arg1 = (boost::shared_ptr< Observable > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QlArray__SWIG_0() {
  void * jresult ;
  Array *result = 0 ;
  
  {
    try {
      result = (Array *)new Array();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QlArray__SWIG_1(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Array *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Array *)new Array(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QlArray__SWIG_2(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  Array *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (Array *)new Array(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QlArray__SWIG_3(void * jarg1) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Array *)new Array((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QlArray_size(void * jarg1) {
  unsigned long jresult ;
  Array *arg1 = (Array *) 0 ;
  Size result;
  
  arg1 = (Array *)jarg1; 
  {
    try {
      result = ((Array const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_QlArray___str__(void * jarg1) {
  char * jresult ;
  Array *arg1 = (Array *) 0 ;
  std::string result;
  
  arg1 = (Array *)jarg1; 
  {
    try {
      result = Array___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QlArray_get(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Array *arg1 = (Array *) 0 ;
  Size arg2 ;
  Real result;
  
  arg1 = (Array *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)Array_get(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QlArray_set(void * jarg1, unsigned long jarg2, double jarg3) {
  Array *arg1 = (Array *) 0 ;
  Size arg2 ;
  Real arg3 ;
  
  arg1 = (Array *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      Array_set(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QlArray(void * jarg1) {
  Array *arg1 = (Array *) 0 ;
  
  arg1 = (Array *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_LexicographicalView_xSize(void * jarg1) {
  unsigned long jresult ;
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 0 ;
  Size result;
  
  arg1 = (DefaultLexicographicalView *)jarg1; 
  {
    try {
      result = ((DefaultLexicographicalView const *)arg1)->xSize();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_LexicographicalView_ySize(void * jarg1) {
  unsigned long jresult ;
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 0 ;
  Size result;
  
  arg1 = (DefaultLexicographicalView *)jarg1; 
  {
    try {
      result = ((DefaultLexicographicalView const *)arg1)->ySize();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LexicographicalView(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Size arg2 ;
  DefaultLexicographicalView *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (DefaultLexicographicalView *)new_DefaultLexicographicalView(*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_LexicographicalView___str__(void * jarg1) {
  char * jresult ;
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 0 ;
  std::string result;
  
  arg1 = (DefaultLexicographicalView *)jarg1; 
  {
    try {
      result = DefaultLexicographicalView___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LexicographicalView(void * jarg1) {
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 0 ;
  
  arg1 = (DefaultLexicographicalView *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Matrix__SWIG_0() {
  void * jresult ;
  Matrix *result = 0 ;
  
  {
    try {
      result = (Matrix *)new Matrix();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Matrix__SWIG_1(unsigned long jarg1, unsigned long jarg2, double jarg3) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Real arg3 ;
  Matrix *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Matrix *)new Matrix(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Matrix__SWIG_2(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Matrix *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Matrix *)new Matrix(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Matrix__SWIG_3(void * jarg1) {
  void * jresult ;
  Matrix *arg1 = 0 ;
  Matrix *result = 0 ;
  
  arg1 = (Matrix *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Matrix *)new Matrix((Matrix const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Matrix_rows(void * jarg1) {
  unsigned long jresult ;
  Matrix *arg1 = (Matrix *) 0 ;
  Size result;
  
  arg1 = (Matrix *)jarg1; 
  {
    try {
      result = ((Matrix const *)arg1)->rows();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Matrix_columns(void * jarg1) {
  unsigned long jresult ;
  Matrix *arg1 = (Matrix *) 0 ;
  Size result;
  
  arg1 = (Matrix *)jarg1; 
  {
    try {
      result = ((Matrix const *)arg1)->columns();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Matrix___str__(void * jarg1) {
  char * jresult ;
  Matrix *arg1 = (Matrix *) 0 ;
  std::string result;
  
  arg1 = (Matrix *)jarg1; 
  {
    try {
      result = Matrix___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Matrix_get(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  double jresult ;
  Matrix *arg1 = (Matrix *) 0 ;
  Size arg2 ;
  Size arg3 ;
  Real result;
  
  arg1 = (Matrix *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Real)Matrix_get(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Matrix_set(void * jarg1, unsigned long jarg2, unsigned long jarg3, double jarg4) {
  Matrix *arg1 = (Matrix *) 0 ;
  Size arg2 ;
  Size arg3 ;
  Real arg4 ;
  
  arg1 = (Matrix *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      Matrix_set(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Matrix(void * jarg1) {
  Matrix *arg1 = (Matrix *) 0 ;
  
  arg1 = (Matrix *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SalvagingAlgorithm() {
  void * jresult ;
  SalvagingAlgorithm *result = 0 ;
  
  {
    try {
      result = (SalvagingAlgorithm *)new SalvagingAlgorithm();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SalvagingAlgorithm(void * jarg1) {
  SalvagingAlgorithm *arg1 = (SalvagingAlgorithm *) 0 ;
  
  arg1 = (SalvagingAlgorithm *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_transpose(void * jarg1) {
  void * jresult ;
  Matrix *arg1 = 0 ;
  Matrix result;
  
  arg1 = (Matrix *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = transpose((Matrix const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_outerProduct(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Matrix result;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = outerProduct((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_pseudoSqrt(void * jarg1, int jarg2) {
  void * jresult ;
  Matrix *arg1 = 0 ;
  SalvagingAlgorithm::Type arg2 ;
  Matrix result;
  
  arg1 = (Matrix *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg2 = (SalvagingAlgorithm::Type)jarg2; 
  {
    try {
      result = pseudoSqrt((Matrix const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SVD(void * jarg1) {
  void * jresult ;
  Matrix *arg1 = 0 ;
  SVD *result = 0 ;
  
  arg1 = (Matrix *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SVD *)new SVD((Matrix const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SVD_U(void * jarg1) {
  void * jresult ;
  SVD *arg1 = (SVD *) 0 ;
  Matrix *result = 0 ;
  
  arg1 = (SVD *)jarg1; 
  {
    try {
      result = (Matrix *) &((SVD const *)arg1)->U();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SVD_V(void * jarg1) {
  void * jresult ;
  SVD *arg1 = (SVD *) 0 ;
  Matrix *result = 0 ;
  
  arg1 = (SVD *)jarg1; 
  {
    try {
      result = (Matrix *) &((SVD const *)arg1)->V();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SVD_S(void * jarg1) {
  void * jresult ;
  SVD *arg1 = (SVD *) 0 ;
  Matrix result;
  
  arg1 = (SVD *)jarg1; 
  {
    try {
      result = ((SVD const *)arg1)->S();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SVD_singularValues(void * jarg1) {
  void * jresult ;
  SVD *arg1 = (SVD *) 0 ;
  Array *result = 0 ;
  
  arg1 = (SVD *)jarg1; 
  {
    try {
      result = (Array *) &((SVD const *)arg1)->singularValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SVD(void * jarg1) {
  SVD *arg1 = (SVD *) 0 ;
  
  arg1 = (SVD *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnaryFunction(void * jarg1) {
  void * jresult ;
  UnaryFunctionDelegate *arg1 = (UnaryFunctionDelegate *) 0 ;
  UnaryFunction *result = 0 ;
  
  arg1 = (UnaryFunctionDelegate *)jarg1; 
  {
    try {
      result = (UnaryFunction *)new UnaryFunction(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_UnaryFunction_call(void * jarg1, double jarg2) {
  double jresult ;
  UnaryFunction *arg1 = (UnaryFunction *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (UnaryFunction *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((UnaryFunction const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UnaryFunction(void * jarg1) {
  UnaryFunction *arg1 = (UnaryFunction *) 0 ;
  
  arg1 = (UnaryFunction *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UnaryFunctionDelegate(void * jarg1) {
  UnaryFunctionDelegate *arg1 = (UnaryFunctionDelegate *) 0 ;
  
  arg1 = (UnaryFunctionDelegate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_UnaryFunctionDelegate_value(void * jarg1, double jarg2) {
  double jresult ;
  UnaryFunctionDelegate *arg1 = (UnaryFunctionDelegate *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (UnaryFunctionDelegate *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((UnaryFunctionDelegate const *)arg1)->value(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_UnaryFunctionDelegate_valueSwigExplicitUnaryFunctionDelegate(void * jarg1, double jarg2) {
  double jresult ;
  UnaryFunctionDelegate *arg1 = (UnaryFunctionDelegate *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (UnaryFunctionDelegate *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((UnaryFunctionDelegate const *)arg1)->UnaryFunctionDelegate::value(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnaryFunctionDelegate() {
  void * jresult ;
  UnaryFunctionDelegate *result = 0 ;
  
  {
    try {
      result = (UnaryFunctionDelegate *)new SwigDirector_UnaryFunctionDelegate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnaryFunctionDelegate_director_connect(void *objarg, SwigDirector_UnaryFunctionDelegate::SWIG_Callback0_t callback0) {
  UnaryFunctionDelegate *obj = (UnaryFunctionDelegate *)objarg;
  SwigDirector_UnaryFunctionDelegate *director = dynamic_cast<SwigDirector_UnaryFunctionDelegate *>(obj);
  if (director) {
    director->swig_connect_director(callback0);
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DotNetCostFunction(void * jarg1) {
  void * jresult ;
  CostFunctionDelegate *arg1 = (CostFunctionDelegate *) 0 ;
  DotNetCostFunction *result = 0 ;
  
  arg1 = (CostFunctionDelegate *)jarg1; 
  {
    try {
      result = (DotNetCostFunction *)new DotNetCostFunction(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DotNetCostFunction(void * jarg1) {
  DotNetCostFunction *arg1 = (DotNetCostFunction *) 0 ;
  
  arg1 = (DotNetCostFunction *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DotNetCostFunction_value(void * jarg1, void * jarg2) {
  double jresult ;
  DotNetCostFunction *arg1 = (DotNetCostFunction *) 0 ;
  Array *arg2 = 0 ;
  Real result;
  
  arg1 = (DotNetCostFunction *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((DotNetCostFunction const *)arg1)->value((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DotNetCostFunction_values(void * jarg1, void * jarg2) {
  void * jresult ;
  DotNetCostFunction *arg1 = (DotNetCostFunction *) 0 ;
  Array *arg2 = 0 ;
  SwigValueWrapper< Disposable< Array > > result;
  
  arg1 = (DotNetCostFunction *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((DotNetCostFunction const *)arg1)->values((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Disposable< Array >((const Disposable< Array > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CostFunctionDelegate(void * jarg1) {
  CostFunctionDelegate *arg1 = (CostFunctionDelegate *) 0 ;
  
  arg1 = (CostFunctionDelegate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CostFunctionDelegate_value(void * jarg1, void * jarg2) {
  double jresult ;
  CostFunctionDelegate *arg1 = (CostFunctionDelegate *) 0 ;
  Array *arg2 = 0 ;
  Real result;
  
  arg1 = (CostFunctionDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((CostFunctionDelegate const *)arg1)->value((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CostFunctionDelegate_valueSwigExplicitCostFunctionDelegate(void * jarg1, void * jarg2) {
  double jresult ;
  CostFunctionDelegate *arg1 = (CostFunctionDelegate *) 0 ;
  Array *arg2 = 0 ;
  Real result;
  
  arg1 = (CostFunctionDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((CostFunctionDelegate const *)arg1)->CostFunctionDelegate::value((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CostFunctionDelegate_values(void * jarg1, void * jarg2) {
  void * jresult ;
  CostFunctionDelegate *arg1 = (CostFunctionDelegate *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (CostFunctionDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((CostFunctionDelegate const *)arg1)->values((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CostFunctionDelegate_valuesSwigExplicitCostFunctionDelegate(void * jarg1, void * jarg2) {
  void * jresult ;
  CostFunctionDelegate *arg1 = (CostFunctionDelegate *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (CostFunctionDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((CostFunctionDelegate const *)arg1)->CostFunctionDelegate::values((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CostFunctionDelegate() {
  void * jresult ;
  CostFunctionDelegate *result = 0 ;
  
  {
    try {
      result = (CostFunctionDelegate *)new SwigDirector_CostFunctionDelegate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CostFunctionDelegate_director_connect(void *objarg, SwigDirector_CostFunctionDelegate::SWIG_Callback0_t callback0, SwigDirector_CostFunctionDelegate::SWIG_Callback1_t callback1) {
  CostFunctionDelegate *obj = (CostFunctionDelegate *)objarg;
  SwigDirector_CostFunctionDelegate *director = dynamic_cast<SwigDirector_CostFunctionDelegate *>(obj);
  if (director) {
    director->swig_connect_director(callback0, callback1);
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Quote___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Quote > *arg1 = (boost::shared_ptr< Quote > *) 0 ;
  Quote *result = 0 ;
  
  arg1 = (boost::shared_ptr< Quote > *)jarg1; 
  {
    try {
      result = (Quote *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Quote_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Quote > *arg1 = (boost::shared_ptr< Quote > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Quote > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Quote_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Quote_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Quote > *arg1 = (boost::shared_ptr< Quote > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< Quote > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_Quote_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Quote() {
  void * jresult ;
  boost::shared_ptr< Quote > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Quote > *)new boost::shared_ptr< Quote >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Quote(void * jarg1) {
  boost::shared_ptr< Quote > *arg1 = (boost::shared_ptr< Quote > *) 0 ;
  
  arg1 = (boost::shared_ptr< Quote > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Quote_value(void * jarg1) {
  double jresult ;
  boost::shared_ptr< Quote > *arg1 = (boost::shared_ptr< Quote > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Quote > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->value();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Quote > *arg1 = 0 ;
  Handle< Quote > *result = 0 ;
  
  arg1 = (boost::shared_ptr< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< Quote > *)new Handle< Quote >((boost::shared_ptr< Quote > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandle__SWIG_1() {
  void * jresult ;
  Handle< Quote > *result = 0 ;
  
  {
    try {
      result = (Handle< Quote > *)new Handle< Quote >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  boost::shared_ptr< Quote > result;
  
  arg1 = (Handle< Quote > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Quote >((const boost::shared_ptr< Quote > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_QuoteHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  bool result;
  
  arg1 = (Handle< Quote > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< Quote > *)jarg1; 
  {
    try {
      result = Handle_Sl_Quote_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuoteHandle(void * jarg1) {
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  
  arg1 = (Handle< Quote > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuoteHandle_value(void * jarg1) {
  double jresult ;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  Real result;
  
  arg1 = (Handle< Quote > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->value();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableQuoteHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Quote > *arg1 = 0 ;
  RelinkableHandle< Quote > *result = 0 ;
  
  arg1 = (boost::shared_ptr< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< Quote > *)new RelinkableHandle< Quote >((boost::shared_ptr< Quote > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableQuoteHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< Quote > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< Quote > *)new RelinkableHandle< Quote >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< Quote > *arg1 = (RelinkableHandle< Quote > *) 0 ;
  boost::shared_ptr< Quote > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< Quote > *)jarg1; 
  arg2 = (boost::shared_ptr< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableQuoteHandle(void * jarg1) {
  RelinkableHandle< Quote > *arg1 = (RelinkableHandle< Quote > *) 0 ;
  
  arg1 = (RelinkableHandle< Quote > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SimpleQuote(double jarg1) {
  void * jresult ;
  Real arg1 ;
  SimpleQuotePtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (SimpleQuotePtr *)new_SimpleQuotePtr(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SimpleQuote_setValue(void * jarg1, double jarg2) {
  SimpleQuotePtr *arg1 = (SimpleQuotePtr *) 0 ;
  Real arg2 ;
  
  arg1 = (SimpleQuotePtr *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      SimpleQuotePtr_setValue(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SimpleQuote(void * jarg1) {
  SimpleQuotePtr *arg1 = (SimpleQuotePtr *) 0 ;
  
  arg1 = (SimpleQuotePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  boost::shared_ptr< Quote > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (boost::shared_ptr< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QuoteVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  std::vector< boost::shared_ptr< Quote > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< Quote > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QuoteVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  std::vector< boost::shared_ptr< Quote > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< Quote > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  std::vector< boost::shared_ptr< Quote > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Quote > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteVector__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< Quote > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< Quote > > *)new std::vector< boost::shared_ptr< Quote > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< Quote > > *)new std::vector< boost::shared_ptr< Quote > >((std::vector< boost::shared_ptr< Quote > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Quote > > *)new_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Quote > result;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Quote >((const boost::shared_ptr< Quote > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Quote > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< Quote > *) &std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Quote > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< Quote > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  std::vector< boost::shared_ptr< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< Quote > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Quote > > *)std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Quote > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< Quote > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< Quote > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Quote > > *)std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Repeat((boost::shared_ptr< Quote > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_QuoteVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  boost::shared_ptr< Quote > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (boost::shared_ptr< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Contains(arg1,(boost::shared_ptr< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_QuoteVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  boost::shared_ptr< Quote > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (boost::shared_ptr< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_QuoteVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  boost::shared_ptr< Quote > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (boost::shared_ptr< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_QuoteVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  boost::shared_ptr< Quote > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  arg2 = (boost::shared_ptr< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Remove(arg1,(boost::shared_ptr< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuoteVector(void * jarg1) {
  std::vector< boost::shared_ptr< Quote > > *arg1 = (std::vector< boost::shared_ptr< Quote > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_Clear(void * jarg1) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  std::vector< boost::shared_ptr< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< boost::shared_ptr< Quote > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::vector< boost::shared_ptr< Quote > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::vector< boost::shared_ptr< Quote > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::vector< boost::shared_ptr< Quote > > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteVectorVector__SWIG_0() {
  void * jresult ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)new std::vector< std::vector< boost::shared_ptr< Quote > > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteVectorVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = 0 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< boost::shared_ptr< Quote > > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)new std::vector< std::vector< boost::shared_ptr< Quote > > >((std::vector< std::vector< boost::shared_ptr< Quote > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteVectorVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)new_std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Quote > > result;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< boost::shared_ptr< Quote > >((const std::vector< boost::shared_ptr< Quote > > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Quote > > *) &std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__setitem(arg1,arg2,(std::vector< boost::shared_ptr< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< boost::shared_ptr< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__AddRange(arg1,(std::vector< std::vector< boost::shared_ptr< Quote > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__Insert(arg1,arg2,(std::vector< boost::shared_ptr< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< boost::shared_ptr< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< boost::shared_ptr< Quote > > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Quote > > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Quote > > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__Repeat((std::vector< boost::shared_ptr< Quote > > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< boost::shared_ptr< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_boost_shared_ptr_Sl_Quote_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< boost::shared_ptr< Quote > > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuoteVectorVector(void * jarg1) {
  std::vector< std::vector< boost::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< boost::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_Clear(void * jarg1) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_Add(void * jarg1, void * jarg2) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  Handle< Quote > *arg2 = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::size_type result;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  {
    try {
      result = ((std::vector< Handle< Quote > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::size_type result;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  {
    try {
      result = ((std::vector< Handle< Quote > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::size_type arg2 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (std::vector< Handle< Quote > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandleVector__SWIG_0() {
  void * jresult ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  {
    try {
      result = (std::vector< Handle< Quote > > *)new std::vector< Handle< Quote > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandleVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< Handle< Quote > > *arg1 = 0 ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< Handle< Quote > > *)new std::vector< Handle< Quote > >((std::vector< Handle< Quote > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandleVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< Handle< Quote > > *)new_std_vector_Sl_Handle_Sl_Quote_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  Handle< Quote > result;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_Handle_Sl_Quote_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< Quote >((const Handle< Quote > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  Handle< Quote > *result = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (Handle< Quote > *) &std_vector_Sl_Handle_Sl_Quote_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  Handle< Quote > *arg3 = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg__setitem(arg1,arg2,(Handle< Quote > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_Handle_Sl_Quote_Sg__Sg__AddRange(arg1,(std::vector< Handle< Quote > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< Handle< Quote > > *)std_vector_Sl_Handle_Sl_Quote_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  Handle< Quote > *arg3 = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Insert(arg1,arg2,(Handle< Quote > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg__InsertRange(arg1,arg2,(std::vector< Handle< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  int arg2 ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Handle< Quote > > *)std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Repeat((Handle< Quote > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  {
    try {
      std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  int arg2 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg__SetRange(arg1,arg2,(std::vector< Handle< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  Handle< Quote > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Contains(arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  Handle< Quote > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_Handle_Sl_Quote_Sg__Sg__IndexOf(arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  Handle< Quote > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_Handle_Sl_Quote_Sg__Sg__LastIndexOf(arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_QuoteHandleVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  Handle< Quote > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Remove(arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuoteHandleVector(void * jarg1) {
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_Clear(void * jarg1) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< Handle< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< Handle< Quote > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::vector< Handle< Quote > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::vector< Handle< Quote > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::vector< Handle< Quote > > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandleVectorVector__SWIG_0() {
  void * jresult ;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::vector< Handle< Quote > > > *)new std::vector< std::vector< Handle< Quote > > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandleVectorVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::vector< Handle< Quote > > > *arg1 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::vector< Handle< Quote > > > *)new std::vector< std::vector< Handle< Quote > > >((std::vector< std::vector< Handle< Quote > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandleVectorVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::vector< Handle< Quote > > > *)new_std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< Handle< Quote > > result;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Handle< Quote > >((const std::vector< Handle< Quote > > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Handle< Quote > > *) &std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__setitem(arg1,arg2,(std::vector< Handle< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::vector< Handle< Quote > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__AddRange(arg1,(std::vector< std::vector< Handle< Quote > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::vector< Handle< Quote > > > *)std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__Insert(arg1,arg2,(std::vector< Handle< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< Handle< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< Handle< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< Handle< Quote > > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Handle< Quote > > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< Handle< Quote > > > *)std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__Repeat((std::vector< Handle< Quote > > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteHandleVectorVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< Handle< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< Handle< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< Handle< Quote > > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuoteHandleVectorVector(void * jarg1) {
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_Clear(void * jarg1) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_Add(void * jarg1, void * jarg2) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  RelinkableHandle< Quote > *arg2 = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (RelinkableHandle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RelinkableHandle< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((RelinkableHandle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::size_type result;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  {
    try {
      result = ((std::vector< RelinkableHandle< Quote > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::size_type result;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  {
    try {
      result = ((std::vector< RelinkableHandle< Quote > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::size_type arg2 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (std::vector< RelinkableHandle< Quote > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableQuoteHandleVector__SWIG_0() {
  void * jresult ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  {
    try {
      result = (std::vector< RelinkableHandle< Quote > > *)new std::vector< RelinkableHandle< Quote > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableQuoteHandleVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = 0 ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RelinkableHandle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< RelinkableHandle< Quote > > *)new std::vector< RelinkableHandle< Quote > >((std::vector< RelinkableHandle< Quote > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableQuoteHandleVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< RelinkableHandle< Quote > > *)new_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  RelinkableHandle< Quote > result;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new RelinkableHandle< Quote >((const RelinkableHandle< Quote > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  RelinkableHandle< Quote > *result = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (RelinkableHandle< Quote > *) &std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  RelinkableHandle< Quote > *arg3 = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RelinkableHandle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RelinkableHandle< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__setitem(arg1,arg2,(RelinkableHandle< Quote > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (std::vector< RelinkableHandle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RelinkableHandle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__AddRange(arg1,(std::vector< RelinkableHandle< Quote > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< RelinkableHandle< Quote > > *)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  RelinkableHandle< Quote > *arg3 = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RelinkableHandle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RelinkableHandle< Quote > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Insert(arg1,arg2,(RelinkableHandle< Quote > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  std::vector< RelinkableHandle< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RelinkableHandle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RelinkableHandle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__InsertRange(arg1,arg2,(std::vector< RelinkableHandle< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RelinkableHandle< Quote > *arg1 = 0 ;
  int arg2 ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  arg1 = (RelinkableHandle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RelinkableHandle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< RelinkableHandle< Quote > > *)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Repeat((RelinkableHandle< Quote > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  {
    try {
      std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  int arg2 ;
  std::vector< RelinkableHandle< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RelinkableHandle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RelinkableHandle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__SetRange(arg1,arg2,(std::vector< RelinkableHandle< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  RelinkableHandle< Quote > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (RelinkableHandle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RelinkableHandle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Contains(arg1,(RelinkableHandle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  RelinkableHandle< Quote > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (RelinkableHandle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RelinkableHandle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__IndexOf(arg1,(RelinkableHandle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  RelinkableHandle< Quote > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (RelinkableHandle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RelinkableHandle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__LastIndexOf(arg1,(RelinkableHandle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  RelinkableHandle< Quote > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (RelinkableHandle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RelinkableHandle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Remove(arg1,(RelinkableHandle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableQuoteHandleVector(void * jarg1) {
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_Clear(void * jarg1) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< RelinkableHandle< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (std::vector< RelinkableHandle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RelinkableHandle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< RelinkableHandle< Quote > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::vector< RelinkableHandle< Quote > > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableQuoteHandleVectorVector__SWIG_0() {
  void * jresult ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)new std::vector< std::vector< RelinkableHandle< Quote > > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableQuoteHandleVectorVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< RelinkableHandle< Quote > > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)new std::vector< std::vector< RelinkableHandle< Quote > > >((std::vector< std::vector< RelinkableHandle< Quote > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableQuoteHandleVectorVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)new_std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< RelinkableHandle< Quote > > result;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< RelinkableHandle< Quote > >((const std::vector< RelinkableHandle< Quote > > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< RelinkableHandle< Quote > > *) &std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< RelinkableHandle< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RelinkableHandle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RelinkableHandle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__setitem(arg1,arg2,(std::vector< RelinkableHandle< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< RelinkableHandle< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__AddRange(arg1,(std::vector< std::vector< RelinkableHandle< Quote > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< RelinkableHandle< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RelinkableHandle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RelinkableHandle< Quote > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__Insert(arg1,arg2,(std::vector< RelinkableHandle< Quote > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< RelinkableHandle< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< RelinkableHandle< Quote > > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RelinkableHandle< Quote > > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RelinkableHandle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__Repeat((std::vector< RelinkableHandle< Quote > > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandleVectorVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< RelinkableHandle< Quote > > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< RelinkableHandle< Quote > > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableQuoteHandleVectorVector(void * jarg1) {
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Calendar_isWeekend(void * jarg1, int jarg2) {
  unsigned int jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Weekday arg2 ;
  bool result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Weekday)jarg2; 
  {
    try {
      result = (bool)(arg1)->isWeekend(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_endOfMonth(void * jarg1, void * jarg2) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->endOfMonth((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Calendar_isBusinessDay(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  bool result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)(arg1)->isBusinessDay((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Calendar_isHoliday(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  bool result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)(arg1)->isHoliday((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Calendar_isEndOfMonth(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  bool result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)(arg1)->isEndOfMonth((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Calendar_addHoliday(void * jarg1, void * jarg2) {
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->addHoliday((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Calendar_removeHoliday(void * jarg1, void * jarg2) {
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->removeHoliday((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_adjust__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  {
    try {
      result = (arg1)->adjust((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_adjust__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->adjust((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_advance__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Integer arg3 ;
  TimeUnit arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (TimeUnit)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_advance__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Integer arg3 ;
  TimeUnit arg4 ;
  BusinessDayConvention arg5 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (TimeUnit)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_advance__SWIG_2(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Integer arg3 ;
  TimeUnit arg4 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (TimeUnit)jarg4; 
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_advance__SWIG_3(void * jarg1, void * jarg2, void * jarg3, int jarg4, unsigned int jarg5) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  bool arg5 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (BusinessDayConvention)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_advance__SWIG_4(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (BusinessDayConvention)jarg4; 
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_advance__SWIG_5(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_Calendar_businessDaysBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) {
  long jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  BigInteger result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (BigInteger)(arg1)->businessDaysBetween((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_Calendar_businessDaysBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  long jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  BigInteger result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (BigInteger)(arg1)->businessDaysBetween((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_Calendar_businessDaysBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  long jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  BigInteger result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BigInteger)(arg1)->businessDaysBetween((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Calendar_name(void * jarg1) {
  char * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  std::string result;
  
  arg1 = (Calendar *)jarg1; 
  {
    try {
      result = (arg1)->name();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Calendar___str__(void * jarg1) {
  char * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  std::string result;
  
  arg1 = (Calendar *)jarg1; 
  {
    try {
      result = Calendar___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Calendar(void * jarg1) {
  Calendar *arg1 = (Calendar *) 0 ;
  
  arg1 = (Calendar *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Argentina__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Argentina::Market arg1 ;
  QuantLib::Argentina *result = 0 ;
  
  arg1 = (QuantLib::Argentina::Market)jarg1; 
  {
    try {
      result = (QuantLib::Argentina *)new QuantLib::Argentina(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Argentina__SWIG_1() {
  void * jresult ;
  QuantLib::Argentina *result = 0 ;
  
  {
    try {
      result = (QuantLib::Argentina *)new QuantLib::Argentina();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Argentina(void * jarg1) {
  QuantLib::Argentina *arg1 = (QuantLib::Argentina *) 0 ;
  
  arg1 = (QuantLib::Argentina *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Australia() {
  void * jresult ;
  QuantLib::Australia *result = 0 ;
  
  {
    try {
      result = (QuantLib::Australia *)new QuantLib::Australia();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Australia(void * jarg1) {
  QuantLib::Australia *arg1 = (QuantLib::Australia *) 0 ;
  
  arg1 = (QuantLib::Australia *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Brazil__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Brazil::Market arg1 ;
  QuantLib::Brazil *result = 0 ;
  
  arg1 = (QuantLib::Brazil::Market)jarg1; 
  {
    try {
      result = (QuantLib::Brazil *)new QuantLib::Brazil(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Brazil__SWIG_1() {
  void * jresult ;
  QuantLib::Brazil *result = 0 ;
  
  {
    try {
      result = (QuantLib::Brazil *)new QuantLib::Brazil();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Brazil(void * jarg1) {
  QuantLib::Brazil *arg1 = (QuantLib::Brazil *) 0 ;
  
  arg1 = (QuantLib::Brazil *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Canada__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Canada::Market arg1 ;
  QuantLib::Canada *result = 0 ;
  
  arg1 = (QuantLib::Canada::Market)jarg1; 
  {
    try {
      result = (QuantLib::Canada *)new QuantLib::Canada(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Canada__SWIG_1() {
  void * jresult ;
  QuantLib::Canada *result = 0 ;
  
  {
    try {
      result = (QuantLib::Canada *)new QuantLib::Canada();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Canada(void * jarg1) {
  QuantLib::Canada *arg1 = (QuantLib::Canada *) 0 ;
  
  arg1 = (QuantLib::Canada *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_China__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::China::Market arg1 ;
  QuantLib::China *result = 0 ;
  
  arg1 = (QuantLib::China::Market)jarg1; 
  {
    try {
      result = (QuantLib::China *)new QuantLib::China(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_China__SWIG_1() {
  void * jresult ;
  QuantLib::China *result = 0 ;
  
  {
    try {
      result = (QuantLib::China *)new QuantLib::China();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_China(void * jarg1) {
  QuantLib::China *arg1 = (QuantLib::China *) 0 ;
  
  arg1 = (QuantLib::China *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CzechRepublic__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::CzechRepublic::Market arg1 ;
  QuantLib::CzechRepublic *result = 0 ;
  
  arg1 = (QuantLib::CzechRepublic::Market)jarg1; 
  {
    try {
      result = (QuantLib::CzechRepublic *)new QuantLib::CzechRepublic(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CzechRepublic__SWIG_1() {
  void * jresult ;
  QuantLib::CzechRepublic *result = 0 ;
  
  {
    try {
      result = (QuantLib::CzechRepublic *)new QuantLib::CzechRepublic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CzechRepublic(void * jarg1) {
  QuantLib::CzechRepublic *arg1 = (QuantLib::CzechRepublic *) 0 ;
  
  arg1 = (QuantLib::CzechRepublic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Denmark() {
  void * jresult ;
  QuantLib::Denmark *result = 0 ;
  
  {
    try {
      result = (QuantLib::Denmark *)new QuantLib::Denmark();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Denmark(void * jarg1) {
  QuantLib::Denmark *arg1 = (QuantLib::Denmark *) 0 ;
  
  arg1 = (QuantLib::Denmark *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Finland() {
  void * jresult ;
  QuantLib::Finland *result = 0 ;
  
  {
    try {
      result = (QuantLib::Finland *)new QuantLib::Finland();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Finland(void * jarg1) {
  QuantLib::Finland *arg1 = (QuantLib::Finland *) 0 ;
  
  arg1 = (QuantLib::Finland *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Germany__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Germany::Market arg1 ;
  QuantLib::Germany *result = 0 ;
  
  arg1 = (QuantLib::Germany::Market)jarg1; 
  {
    try {
      result = (QuantLib::Germany *)new QuantLib::Germany(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Germany__SWIG_1() {
  void * jresult ;
  QuantLib::Germany *result = 0 ;
  
  {
    try {
      result = (QuantLib::Germany *)new QuantLib::Germany();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Germany(void * jarg1) {
  QuantLib::Germany *arg1 = (QuantLib::Germany *) 0 ;
  
  arg1 = (QuantLib::Germany *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HongKong__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::HongKong::Market arg1 ;
  QuantLib::HongKong *result = 0 ;
  
  arg1 = (QuantLib::HongKong::Market)jarg1; 
  {
    try {
      result = (QuantLib::HongKong *)new QuantLib::HongKong(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HongKong__SWIG_1() {
  void * jresult ;
  QuantLib::HongKong *result = 0 ;
  
  {
    try {
      result = (QuantLib::HongKong *)new QuantLib::HongKong();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HongKong(void * jarg1) {
  QuantLib::HongKong *arg1 = (QuantLib::HongKong *) 0 ;
  
  arg1 = (QuantLib::HongKong *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Hungary() {
  void * jresult ;
  QuantLib::Hungary *result = 0 ;
  
  {
    try {
      result = (QuantLib::Hungary *)new QuantLib::Hungary();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Hungary(void * jarg1) {
  QuantLib::Hungary *arg1 = (QuantLib::Hungary *) 0 ;
  
  arg1 = (QuantLib::Hungary *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Iceland__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Iceland::Market arg1 ;
  QuantLib::Iceland *result = 0 ;
  
  arg1 = (QuantLib::Iceland::Market)jarg1; 
  {
    try {
      result = (QuantLib::Iceland *)new QuantLib::Iceland(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Iceland__SWIG_1() {
  void * jresult ;
  QuantLib::Iceland *result = 0 ;
  
  {
    try {
      result = (QuantLib::Iceland *)new QuantLib::Iceland();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Iceland(void * jarg1) {
  QuantLib::Iceland *arg1 = (QuantLib::Iceland *) 0 ;
  
  arg1 = (QuantLib::Iceland *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_India__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::India::Market arg1 ;
  QuantLib::India *result = 0 ;
  
  arg1 = (QuantLib::India::Market)jarg1; 
  {
    try {
      result = (QuantLib::India *)new QuantLib::India(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_India__SWIG_1() {
  void * jresult ;
  QuantLib::India *result = 0 ;
  
  {
    try {
      result = (QuantLib::India *)new QuantLib::India();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_India(void * jarg1) {
  QuantLib::India *arg1 = (QuantLib::India *) 0 ;
  
  arg1 = (QuantLib::India *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Indonesia__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Indonesia::Market arg1 ;
  QuantLib::Indonesia *result = 0 ;
  
  arg1 = (QuantLib::Indonesia::Market)jarg1; 
  {
    try {
      result = (QuantLib::Indonesia *)new QuantLib::Indonesia(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Indonesia__SWIG_1() {
  void * jresult ;
  QuantLib::Indonesia *result = 0 ;
  
  {
    try {
      result = (QuantLib::Indonesia *)new QuantLib::Indonesia();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Indonesia(void * jarg1) {
  QuantLib::Indonesia *arg1 = (QuantLib::Indonesia *) 0 ;
  
  arg1 = (QuantLib::Indonesia *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Israel__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Israel::Market arg1 ;
  QuantLib::Israel *result = 0 ;
  
  arg1 = (QuantLib::Israel::Market)jarg1; 
  {
    try {
      result = (QuantLib::Israel *)new QuantLib::Israel(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Israel__SWIG_1() {
  void * jresult ;
  QuantLib::Israel *result = 0 ;
  
  {
    try {
      result = (QuantLib::Israel *)new QuantLib::Israel();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Israel(void * jarg1) {
  QuantLib::Israel *arg1 = (QuantLib::Israel *) 0 ;
  
  arg1 = (QuantLib::Israel *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Italy__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Italy::Market arg1 ;
  QuantLib::Italy *result = 0 ;
  
  arg1 = (QuantLib::Italy::Market)jarg1; 
  {
    try {
      result = (QuantLib::Italy *)new QuantLib::Italy(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Italy__SWIG_1() {
  void * jresult ;
  QuantLib::Italy *result = 0 ;
  
  {
    try {
      result = (QuantLib::Italy *)new QuantLib::Italy();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Italy(void * jarg1) {
  QuantLib::Italy *arg1 = (QuantLib::Italy *) 0 ;
  
  arg1 = (QuantLib::Italy *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Japan() {
  void * jresult ;
  QuantLib::Japan *result = 0 ;
  
  {
    try {
      result = (QuantLib::Japan *)new QuantLib::Japan();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Japan(void * jarg1) {
  QuantLib::Japan *arg1 = (QuantLib::Japan *) 0 ;
  
  arg1 = (QuantLib::Japan *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Mexico__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Mexico::Market arg1 ;
  QuantLib::Mexico *result = 0 ;
  
  arg1 = (QuantLib::Mexico::Market)jarg1; 
  {
    try {
      result = (QuantLib::Mexico *)new QuantLib::Mexico(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Mexico__SWIG_1() {
  void * jresult ;
  QuantLib::Mexico *result = 0 ;
  
  {
    try {
      result = (QuantLib::Mexico *)new QuantLib::Mexico();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Mexico(void * jarg1) {
  QuantLib::Mexico *arg1 = (QuantLib::Mexico *) 0 ;
  
  arg1 = (QuantLib::Mexico *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NewZealand() {
  void * jresult ;
  QuantLib::NewZealand *result = 0 ;
  
  {
    try {
      result = (QuantLib::NewZealand *)new QuantLib::NewZealand();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NewZealand(void * jarg1) {
  QuantLib::NewZealand *arg1 = (QuantLib::NewZealand *) 0 ;
  
  arg1 = (QuantLib::NewZealand *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Norway() {
  void * jresult ;
  QuantLib::Norway *result = 0 ;
  
  {
    try {
      result = (QuantLib::Norway *)new QuantLib::Norway();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Norway(void * jarg1) {
  QuantLib::Norway *arg1 = (QuantLib::Norway *) 0 ;
  
  arg1 = (QuantLib::Norway *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Poland() {
  void * jresult ;
  QuantLib::Poland *result = 0 ;
  
  {
    try {
      result = (QuantLib::Poland *)new QuantLib::Poland();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Poland(void * jarg1) {
  QuantLib::Poland *arg1 = (QuantLib::Poland *) 0 ;
  
  arg1 = (QuantLib::Poland *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Russia__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Russia::Market arg1 ;
  QuantLib::Russia *result = 0 ;
  
  arg1 = (QuantLib::Russia::Market)jarg1; 
  {
    try {
      result = (QuantLib::Russia *)new QuantLib::Russia(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Russia__SWIG_1() {
  void * jresult ;
  QuantLib::Russia *result = 0 ;
  
  {
    try {
      result = (QuantLib::Russia *)new QuantLib::Russia();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Russia(void * jarg1) {
  QuantLib::Russia *arg1 = (QuantLib::Russia *) 0 ;
  
  arg1 = (QuantLib::Russia *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Romania() {
  void * jresult ;
  QuantLib::Romania *result = 0 ;
  
  {
    try {
      result = (QuantLib::Romania *)new QuantLib::Romania();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Romania(void * jarg1) {
  QuantLib::Romania *arg1 = (QuantLib::Romania *) 0 ;
  
  arg1 = (QuantLib::Romania *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SaudiArabia__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::SaudiArabia::Market arg1 ;
  QuantLib::SaudiArabia *result = 0 ;
  
  arg1 = (QuantLib::SaudiArabia::Market)jarg1; 
  {
    try {
      result = (QuantLib::SaudiArabia *)new QuantLib::SaudiArabia(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SaudiArabia__SWIG_1() {
  void * jresult ;
  QuantLib::SaudiArabia *result = 0 ;
  
  {
    try {
      result = (QuantLib::SaudiArabia *)new QuantLib::SaudiArabia();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SaudiArabia(void * jarg1) {
  QuantLib::SaudiArabia *arg1 = (QuantLib::SaudiArabia *) 0 ;
  
  arg1 = (QuantLib::SaudiArabia *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Singapore__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Singapore::Market arg1 ;
  QuantLib::Singapore *result = 0 ;
  
  arg1 = (QuantLib::Singapore::Market)jarg1; 
  {
    try {
      result = (QuantLib::Singapore *)new QuantLib::Singapore(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Singapore__SWIG_1() {
  void * jresult ;
  QuantLib::Singapore *result = 0 ;
  
  {
    try {
      result = (QuantLib::Singapore *)new QuantLib::Singapore();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Singapore(void * jarg1) {
  QuantLib::Singapore *arg1 = (QuantLib::Singapore *) 0 ;
  
  arg1 = (QuantLib::Singapore *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Slovakia__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Slovakia::Market arg1 ;
  QuantLib::Slovakia *result = 0 ;
  
  arg1 = (QuantLib::Slovakia::Market)jarg1; 
  {
    try {
      result = (QuantLib::Slovakia *)new QuantLib::Slovakia(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Slovakia__SWIG_1() {
  void * jresult ;
  QuantLib::Slovakia *result = 0 ;
  
  {
    try {
      result = (QuantLib::Slovakia *)new QuantLib::Slovakia();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Slovakia(void * jarg1) {
  QuantLib::Slovakia *arg1 = (QuantLib::Slovakia *) 0 ;
  
  arg1 = (QuantLib::Slovakia *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SouthAfrica() {
  void * jresult ;
  QuantLib::SouthAfrica *result = 0 ;
  
  {
    try {
      result = (QuantLib::SouthAfrica *)new QuantLib::SouthAfrica();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SouthAfrica(void * jarg1) {
  QuantLib::SouthAfrica *arg1 = (QuantLib::SouthAfrica *) 0 ;
  
  arg1 = (QuantLib::SouthAfrica *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SouthKorea__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::SouthKorea::Market arg1 ;
  QuantLib::SouthKorea *result = 0 ;
  
  arg1 = (QuantLib::SouthKorea::Market)jarg1; 
  {
    try {
      result = (QuantLib::SouthKorea *)new QuantLib::SouthKorea(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SouthKorea__SWIG_1() {
  void * jresult ;
  QuantLib::SouthKorea *result = 0 ;
  
  {
    try {
      result = (QuantLib::SouthKorea *)new QuantLib::SouthKorea();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SouthKorea(void * jarg1) {
  QuantLib::SouthKorea *arg1 = (QuantLib::SouthKorea *) 0 ;
  
  arg1 = (QuantLib::SouthKorea *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Sweden() {
  void * jresult ;
  QuantLib::Sweden *result = 0 ;
  
  {
    try {
      result = (QuantLib::Sweden *)new QuantLib::Sweden();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Sweden(void * jarg1) {
  QuantLib::Sweden *arg1 = (QuantLib::Sweden *) 0 ;
  
  arg1 = (QuantLib::Sweden *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Switzerland() {
  void * jresult ;
  QuantLib::Switzerland *result = 0 ;
  
  {
    try {
      result = (QuantLib::Switzerland *)new QuantLib::Switzerland();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Switzerland(void * jarg1) {
  QuantLib::Switzerland *arg1 = (QuantLib::Switzerland *) 0 ;
  
  arg1 = (QuantLib::Switzerland *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Taiwan__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Taiwan::Market arg1 ;
  QuantLib::Taiwan *result = 0 ;
  
  arg1 = (QuantLib::Taiwan::Market)jarg1; 
  {
    try {
      result = (QuantLib::Taiwan *)new QuantLib::Taiwan(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Taiwan__SWIG_1() {
  void * jresult ;
  QuantLib::Taiwan *result = 0 ;
  
  {
    try {
      result = (QuantLib::Taiwan *)new QuantLib::Taiwan();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Taiwan(void * jarg1) {
  QuantLib::Taiwan *arg1 = (QuantLib::Taiwan *) 0 ;
  
  arg1 = (QuantLib::Taiwan *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TARGET() {
  void * jresult ;
  QuantLib::TARGET *result = 0 ;
  
  {
    try {
      result = (QuantLib::TARGET *)new QuantLib::TARGET();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TARGET(void * jarg1) {
  QuantLib::TARGET *arg1 = (QuantLib::TARGET *) 0 ;
  
  arg1 = (QuantLib::TARGET *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Turkey() {
  void * jresult ;
  QuantLib::Turkey *result = 0 ;
  
  {
    try {
      result = (QuantLib::Turkey *)new QuantLib::Turkey();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Turkey(void * jarg1) {
  QuantLib::Turkey *arg1 = (QuantLib::Turkey *) 0 ;
  
  arg1 = (QuantLib::Turkey *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Ukraine__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Ukraine::Market arg1 ;
  QuantLib::Ukraine *result = 0 ;
  
  arg1 = (QuantLib::Ukraine::Market)jarg1; 
  {
    try {
      result = (QuantLib::Ukraine *)new QuantLib::Ukraine(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Ukraine__SWIG_1() {
  void * jresult ;
  QuantLib::Ukraine *result = 0 ;
  
  {
    try {
      result = (QuantLib::Ukraine *)new QuantLib::Ukraine();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Ukraine(void * jarg1) {
  QuantLib::Ukraine *arg1 = (QuantLib::Ukraine *) 0 ;
  
  arg1 = (QuantLib::Ukraine *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnitedKingdom__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::UnitedKingdom::Market arg1 ;
  QuantLib::UnitedKingdom *result = 0 ;
  
  arg1 = (QuantLib::UnitedKingdom::Market)jarg1; 
  {
    try {
      result = (QuantLib::UnitedKingdom *)new QuantLib::UnitedKingdom(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnitedKingdom__SWIG_1() {
  void * jresult ;
  QuantLib::UnitedKingdom *result = 0 ;
  
  {
    try {
      result = (QuantLib::UnitedKingdom *)new QuantLib::UnitedKingdom();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UnitedKingdom(void * jarg1) {
  QuantLib::UnitedKingdom *arg1 = (QuantLib::UnitedKingdom *) 0 ;
  
  arg1 = (QuantLib::UnitedKingdom *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnitedStates__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::UnitedStates::Market arg1 ;
  QuantLib::UnitedStates *result = 0 ;
  
  arg1 = (QuantLib::UnitedStates::Market)jarg1; 
  {
    try {
      result = (QuantLib::UnitedStates *)new QuantLib::UnitedStates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnitedStates__SWIG_1() {
  void * jresult ;
  QuantLib::UnitedStates *result = 0 ;
  
  {
    try {
      result = (QuantLib::UnitedStates *)new QuantLib::UnitedStates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UnitedStates(void * jarg1) {
  QuantLib::UnitedStates *arg1 = (QuantLib::UnitedStates *) 0 ;
  
  arg1 = (QuantLib::UnitedStates *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NullCalendar() {
  void * jresult ;
  QuantLib::NullCalendar *result = 0 ;
  
  {
    try {
      result = (QuantLib::NullCalendar *)new QuantLib::NullCalendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NullCalendar(void * jarg1) {
  QuantLib::NullCalendar *arg1 = (QuantLib::NullCalendar *) 0 ;
  
  arg1 = (QuantLib::NullCalendar *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_WeekendsOnly() {
  void * jresult ;
  QuantLib::WeekendsOnly *result = 0 ;
  
  {
    try {
      result = (QuantLib::WeekendsOnly *)new QuantLib::WeekendsOnly();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_WeekendsOnly(void * jarg1) {
  QuantLib::WeekendsOnly *arg1 = (QuantLib::WeekendsOnly *) 0 ;
  
  arg1 = (QuantLib::WeekendsOnly *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JointCalendar__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  JointCalendarRule arg3 ;
  QuantLib::JointCalendar *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (JointCalendarRule)jarg3; 
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JointCalendar__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JointCalendar__SWIG_2(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  JointCalendarRule arg4 ;
  QuantLib::JointCalendar *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (JointCalendarRule)jarg4; 
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,(Calendar const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JointCalendar__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,(Calendar const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JointCalendar__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  JointCalendarRule arg5 ;
  QuantLib::JointCalendar *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (JointCalendarRule)jarg5; 
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,(Calendar const &)*arg3,(Calendar const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JointCalendar__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,(Calendar const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JointCalendar(void * jarg1) {
  QuantLib::JointCalendar *arg1 = (QuantLib::JointCalendar *) 0 ;
  
  arg1 = (QuantLib::JointCalendar *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BespokeCalendar(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  QuantLib::BespokeCalendar *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = (QuantLib::BespokeCalendar *)new QuantLib::BespokeCalendar((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BespokeCalendar_addWeekend(void * jarg1, int jarg2) {
  QuantLib::BespokeCalendar *arg1 = (QuantLib::BespokeCalendar *) 0 ;
  Weekday arg2 ;
  
  arg1 = (QuantLib::BespokeCalendar *)jarg1; 
  arg2 = (Weekday)jarg2; 
  {
    try {
      (arg1)->addWeekend(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BespokeCalendar(void * jarg1) {
  QuantLib::BespokeCalendar *arg1 = (QuantLib::BespokeCalendar *) 0 ;
  
  arg1 = (QuantLib::BespokeCalendar *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_nullInt() {
  int jresult ;
  int result;
  
  {
    try {
      result = (int)nullInt();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_nullDouble() {
  double jresult ;
  double result;
  
  {
    try {
      result = (double)nullDouble();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_DayCounter_dayCount(void * jarg1, void * jarg2, void * jarg3) {
  long jresult ;
  DayCounter *arg1 = (DayCounter *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  BigInteger result;
  
  arg1 = (DayCounter *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BigInteger)((DayCounter const *)arg1)->dayCount((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DayCounter_yearFraction__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  DayCounter *arg1 = (DayCounter *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Time result;
  
  arg1 = (DayCounter *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)((DayCounter const *)arg1)->yearFraction((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DayCounter_yearFraction__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  DayCounter *arg1 = (DayCounter *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Time result;
  
  arg1 = (DayCounter *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)((DayCounter const *)arg1)->yearFraction((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DayCounter_yearFraction__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  DayCounter *arg1 = (DayCounter *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Time result;
  
  arg1 = (DayCounter *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)((DayCounter const *)arg1)->yearFraction((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_DayCounter_name(void * jarg1) {
  char * jresult ;
  DayCounter *arg1 = (DayCounter *) 0 ;
  std::string result;
  
  arg1 = (DayCounter *)jarg1; 
  {
    try {
      result = ((DayCounter const *)arg1)->name();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_DayCounter___str__(void * jarg1) {
  char * jresult ;
  DayCounter *arg1 = (DayCounter *) 0 ;
  std::string result;
  
  arg1 = (DayCounter *)jarg1; 
  {
    try {
      result = DayCounter___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DayCounter(void * jarg1) {
  DayCounter *arg1 = (DayCounter *) 0 ;
  
  arg1 = (DayCounter *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Actual360() {
  void * jresult ;
  QuantLib::Actual360 *result = 0 ;
  
  {
    try {
      result = (QuantLib::Actual360 *)new QuantLib::Actual360();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Actual360(void * jarg1) {
  QuantLib::Actual360 *arg1 = (QuantLib::Actual360 *) 0 ;
  
  arg1 = (QuantLib::Actual360 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Actual365Fixed__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Actual365Fixed::Convention arg1 ;
  QuantLib::Actual365Fixed *result = 0 ;
  
  arg1 = (QuantLib::Actual365Fixed::Convention)jarg1; 
  {
    try {
      result = (QuantLib::Actual365Fixed *)new QuantLib::Actual365Fixed(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Actual365Fixed__SWIG_1() {
  void * jresult ;
  QuantLib::Actual365Fixed *result = 0 ;
  
  {
    try {
      result = (QuantLib::Actual365Fixed *)new QuantLib::Actual365Fixed();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Actual365Fixed(void * jarg1) {
  QuantLib::Actual365Fixed *arg1 = (QuantLib::Actual365Fixed *) 0 ;
  
  arg1 = (QuantLib::Actual365Fixed *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Thirty360__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Thirty360::Convention arg1 ;
  QuantLib::Thirty360 *result = 0 ;
  
  arg1 = (QuantLib::Thirty360::Convention)jarg1; 
  {
    try {
      result = (QuantLib::Thirty360 *)new QuantLib::Thirty360(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Thirty360__SWIG_1() {
  void * jresult ;
  QuantLib::Thirty360 *result = 0 ;
  
  {
    try {
      result = (QuantLib::Thirty360 *)new QuantLib::Thirty360();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Thirty360(void * jarg1) {
  QuantLib::Thirty360 *arg1 = (QuantLib::Thirty360 *) 0 ;
  
  arg1 = (QuantLib::Thirty360 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ActualActual__SWIG_0(int jarg1, void * jarg2) {
  void * jresult ;
  QuantLib::ActualActual::Convention arg1 ;
  Schedule *arg2 = 0 ;
  QuantLib::ActualActual *result = 0 ;
  
  arg1 = (QuantLib::ActualActual::Convention)jarg1; 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantLib::ActualActual *)new QuantLib::ActualActual(arg1,(Schedule const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ActualActual__SWIG_1(int jarg1) {
  void * jresult ;
  QuantLib::ActualActual::Convention arg1 ;
  QuantLib::ActualActual *result = 0 ;
  
  arg1 = (QuantLib::ActualActual::Convention)jarg1; 
  {
    try {
      result = (QuantLib::ActualActual *)new QuantLib::ActualActual(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ActualActual__SWIG_2() {
  void * jresult ;
  QuantLib::ActualActual *result = 0 ;
  
  {
    try {
      result = (QuantLib::ActualActual *)new QuantLib::ActualActual();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ActualActual(void * jarg1) {
  QuantLib::ActualActual *arg1 = (QuantLib::ActualActual *) 0 ;
  
  arg1 = (QuantLib::ActualActual *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OneDayCounter() {
  void * jresult ;
  QuantLib::OneDayCounter *result = 0 ;
  
  {
    try {
      result = (QuantLib::OneDayCounter *)new QuantLib::OneDayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OneDayCounter(void * jarg1) {
  QuantLib::OneDayCounter *arg1 = (QuantLib::OneDayCounter *) 0 ;
  
  arg1 = (QuantLib::OneDayCounter *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SimpleDayCounter() {
  void * jresult ;
  QuantLib::SimpleDayCounter *result = 0 ;
  
  {
    try {
      result = (QuantLib::SimpleDayCounter *)new QuantLib::SimpleDayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SimpleDayCounter(void * jarg1) {
  QuantLib::SimpleDayCounter *arg1 = (QuantLib::SimpleDayCounter *) 0 ;
  
  arg1 = (QuantLib::SimpleDayCounter *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Business252__SWIG_0(void * jarg1) {
  void * jresult ;
  SwigValueWrapper< Calendar > arg1 ;
  Calendar *argp1 ;
  QuantLib::Business252 *result = 0 ;
  
  argp1 = (Calendar *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (QuantLib::Business252 *)new QuantLib::Business252(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Business252__SWIG_1() {
  void * jresult ;
  QuantLib::Business252 *result = 0 ;
  
  {
    try {
      result = (QuantLib::Business252 *)new QuantLib::Business252();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Business252(void * jarg1) {
  QuantLib::Business252 *arg1 = (QuantLib::Business252 *) 0 ;
  
  arg1 = (QuantLib::Business252 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Actual365NoLeap() {
  void * jresult ;
  SwigValueWrapper< DayCounter > result;
  
  {
    try {
      result = Actual365NoLeap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterestRate__SWIG_0() {
  void * jresult ;
  InterestRate *result = 0 ;
  
  {
    try {
      result = (InterestRate *)new InterestRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterestRate__SWIG_1(double jarg1, void * jarg2, int jarg3, int jarg4) {
  void * jresult ;
  Rate arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  InterestRate *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (InterestRate *)new InterestRate(arg1,(DayCounter const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_rate(void * jarg1) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Rate result;
  
  arg1 = (InterestRate *)jarg1; 
  {
    try {
      result = (Rate)((InterestRate const *)arg1)->rate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_dayCounter(void * jarg1) {
  void * jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (InterestRate *)jarg1; 
  {
    try {
      result = ((InterestRate const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_InterestRate_compounding(void * jarg1) {
  int jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Compounding result;
  
  arg1 = (InterestRate *)jarg1; 
  {
    try {
      result = (Compounding)((InterestRate const *)arg1)->compounding();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_InterestRate_frequency(void * jarg1) {
  int jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Frequency result;
  
  arg1 = (InterestRate *)jarg1; 
  {
    try {
      result = (Frequency)((InterestRate const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_discountFactor__SWIG_0(void * jarg1, double jarg2) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Time arg2 ;
  DiscountFactor result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)((InterestRate const *)arg1)->discountFactor(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_discountFactor__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  DiscountFactor result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountFactor)((InterestRate const *)arg1)->discountFactor((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_discountFactor__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  DiscountFactor result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountFactor)((InterestRate const *)arg1)->discountFactor((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_discountFactor__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DiscountFactor result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountFactor)((InterestRate const *)arg1)->discountFactor((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_compoundFactor__SWIG_0(void * jarg1, double jarg2) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((InterestRate const *)arg1)->compoundFactor(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_compoundFactor__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Real result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((InterestRate const *)arg1)->compoundFactor((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_compoundFactor__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((InterestRate const *)arg1)->compoundFactor((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InterestRate_compoundFactor__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((InterestRate const *)arg1)->compoundFactor((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_impliedRate__SWIG_0(double jarg1, void * jarg2, int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  Real arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Time arg5 ;
  InterestRate result;
  
  arg1 = (Real)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Time)jarg5; 
  {
    try {
      result = InterestRate::impliedRate(arg1,(DayCounter const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_impliedRate__SWIG_1(double jarg1, void * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Real arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  Date *arg8 = 0 ;
  InterestRate result;
  
  arg1 = (Real)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = InterestRate::impliedRate(arg1,(DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_impliedRate__SWIG_2(double jarg1, void * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Real arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterestRate result;
  
  arg1 = (Real)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = InterestRate::impliedRate(arg1,(DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_impliedRate__SWIG_3(double jarg1, void * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Real arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  InterestRate result;
  
  arg1 = (Real)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = InterestRate::impliedRate(arg1,(DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_equivalentRate__SWIG_0(void * jarg1, int jarg2, int jarg3, double jarg4) {
  void * jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Compounding arg2 ;
  Frequency arg3 ;
  Time arg4 ;
  InterestRate result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (Compounding)jarg2; 
  arg3 = (Frequency)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = ((InterestRate const *)arg1)->equivalentRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_equivalentRate__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  Date *arg8 = 0 ;
  InterestRate result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((InterestRate const *)arg1)->equivalentRate((DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_equivalentRate__SWIG_2(void * jarg1, void * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterestRate result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((InterestRate const *)arg1)->equivalentRate((DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRate_equivalentRate__SWIG_3(void * jarg1, void * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  InterestRate result;
  
  arg1 = (InterestRate *)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((InterestRate const *)arg1)->equivalentRate((DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_InterestRate___str__(void * jarg1) {
  char * jresult ;
  InterestRate *arg1 = (InterestRate *) 0 ;
  std::string result;
  
  arg1 = (InterestRate *)jarg1; 
  {
    try {
      result = InterestRate___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InterestRate(void * jarg1) {
  InterestRate *arg1 = (InterestRate *) 0 ;
  
  arg1 = (InterestRate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_Clear(void * jarg1) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_Add(void * jarg1, void * jarg2) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  InterestRate *arg2 = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InterestRateVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::size_type result;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  {
    try {
      result = ((std::vector< InterestRate > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InterestRateVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::size_type result;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  {
    try {
      result = ((std::vector< InterestRate > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::size_type arg2 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (std::vector< InterestRate >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterestRateVector__SWIG_0() {
  void * jresult ;
  std::vector< InterestRate > *result = 0 ;
  
  {
    try {
      result = (std::vector< InterestRate > *)new std::vector< InterestRate >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterestRateVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< InterestRate > *arg1 = 0 ;
  std::vector< InterestRate > *result = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< InterestRate > *)new std::vector< InterestRate >((std::vector< InterestRate > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterestRateVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< InterestRate > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< InterestRate > *)new_std_vector_Sl_InterestRate_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  InterestRate result;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_InterestRate_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  InterestRate *result = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (InterestRate *) &std_vector_Sl_InterestRate_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  InterestRate *arg3 = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (InterestRate *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg__setitem(arg1,arg2,(InterestRate const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate > *arg2 = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (std::vector< InterestRate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_InterestRate_Sg__AddRange(arg1,(std::vector< InterestRate > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< InterestRate > *result = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< InterestRate > *)std_vector_Sl_InterestRate_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  InterestRate *arg3 = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (InterestRate *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg__Insert(arg1,arg2,(InterestRate const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  std::vector< InterestRate > *arg3 = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< InterestRate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg__InsertRange(arg1,arg2,(std::vector< InterestRate > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  InterestRate *arg1 = 0 ;
  int arg2 ;
  std::vector< InterestRate > *result = 0 ;
  
  arg1 = (InterestRate *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< InterestRate > *)std_vector_Sl_InterestRate_Sg__Repeat((InterestRate const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  {
    try {
      std_vector_Sl_InterestRate_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InterestRateVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  int arg2 ;
  std::vector< InterestRate > *arg3 = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< InterestRate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg__SetRange(arg1,arg2,(std::vector< InterestRate > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InterestRateVector(void * jarg1) {
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Rounding() {
  void * jresult ;
  Rounding *result = 0 ;
  
  {
    try {
      result = (Rounding *)new Rounding();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Rounding_apply(void * jarg1, double jarg2) {
  double jresult ;
  Rounding *arg1 = (Rounding *) 0 ;
  Decimal arg2 ;
  Decimal result;
  
  arg1 = (Rounding *)jarg1; 
  arg2 = (Decimal)jarg2; 
  {
    try {
      result = (Decimal)((Rounding const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Rounding(void * jarg1) {
  Rounding *arg1 = (Rounding *) 0 ;
  
  arg1 = (Rounding *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpRounding__SWIG_0(int jarg1, int jarg2) {
  void * jresult ;
  Integer arg1 ;
  Integer arg2 ;
  UpRounding *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Integer)jarg2; 
  {
    try {
      result = (UpRounding *)new UpRounding(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpRounding__SWIG_1(int jarg1) {
  void * jresult ;
  Integer arg1 ;
  UpRounding *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  {
    try {
      result = (UpRounding *)new UpRounding(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UpRounding(void * jarg1) {
  UpRounding *arg1 = (UpRounding *) 0 ;
  
  arg1 = (UpRounding *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DownRounding__SWIG_0(int jarg1, int jarg2) {
  void * jresult ;
  Integer arg1 ;
  Integer arg2 ;
  DownRounding *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Integer)jarg2; 
  {
    try {
      result = (DownRounding *)new DownRounding(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DownRounding__SWIG_1(int jarg1) {
  void * jresult ;
  Integer arg1 ;
  DownRounding *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  {
    try {
      result = (DownRounding *)new DownRounding(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DownRounding(void * jarg1) {
  DownRounding *arg1 = (DownRounding *) 0 ;
  
  arg1 = (DownRounding *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ClosestRounding__SWIG_0(int jarg1, int jarg2) {
  void * jresult ;
  Integer arg1 ;
  Integer arg2 ;
  ClosestRounding *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Integer)jarg2; 
  {
    try {
      result = (ClosestRounding *)new ClosestRounding(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ClosestRounding__SWIG_1(int jarg1) {
  void * jresult ;
  Integer arg1 ;
  ClosestRounding *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  {
    try {
      result = (ClosestRounding *)new ClosestRounding(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ClosestRounding(void * jarg1) {
  ClosestRounding *arg1 = (ClosestRounding *) 0 ;
  
  arg1 = (ClosestRounding *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CeilingTruncation__SWIG_0(int jarg1, int jarg2) {
  void * jresult ;
  Integer arg1 ;
  Integer arg2 ;
  CeilingTruncation *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Integer)jarg2; 
  {
    try {
      result = (CeilingTruncation *)new CeilingTruncation(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CeilingTruncation__SWIG_1(int jarg1) {
  void * jresult ;
  Integer arg1 ;
  CeilingTruncation *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  {
    try {
      result = (CeilingTruncation *)new CeilingTruncation(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CeilingTruncation(void * jarg1) {
  CeilingTruncation *arg1 = (CeilingTruncation *) 0 ;
  
  arg1 = (CeilingTruncation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloorTruncation__SWIG_0(int jarg1, int jarg2) {
  void * jresult ;
  Integer arg1 ;
  Integer arg2 ;
  FloorTruncation *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Integer)jarg2; 
  {
    try {
      result = (FloorTruncation *)new FloorTruncation(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloorTruncation__SWIG_1(int jarg1) {
  void * jresult ;
  Integer arg1 ;
  FloorTruncation *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  {
    try {
      result = (FloorTruncation *)new FloorTruncation(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloorTruncation(void * jarg1) {
  FloorTruncation *arg1 = (FloorTruncation *) 0 ;
  
  arg1 = (FloorTruncation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Currency_name(void * jarg1) {
  char * jresult ;
  Currency *arg1 = (Currency *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (std::string *) &((Currency const *)arg1)->name();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Currency_code(void * jarg1) {
  char * jresult ;
  Currency *arg1 = (Currency *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (std::string *) &((Currency const *)arg1)->code();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Currency_numericCode(void * jarg1) {
  int jresult ;
  Currency *arg1 = (Currency *) 0 ;
  Integer result;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (Integer)((Currency const *)arg1)->numericCode();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Currency_symbol(void * jarg1) {
  char * jresult ;
  Currency *arg1 = (Currency *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (std::string *) &((Currency const *)arg1)->symbol();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Currency_fractionSymbol(void * jarg1) {
  char * jresult ;
  Currency *arg1 = (Currency *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (std::string *) &((Currency const *)arg1)->fractionSymbol();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Currency_fractionsPerUnit(void * jarg1) {
  int jresult ;
  Currency *arg1 = (Currency *) 0 ;
  Integer result;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (Integer)((Currency const *)arg1)->fractionsPerUnit();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Currency_rounding(void * jarg1) {
  void * jresult ;
  Currency *arg1 = (Currency *) 0 ;
  Rounding *result = 0 ;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (Rounding *) &((Currency const *)arg1)->rounding();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Currency_format(void * jarg1) {
  char * jresult ;
  Currency *arg1 = (Currency *) 0 ;
  std::string result;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = ((Currency const *)arg1)->format();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Currency_empty(void * jarg1) {
  unsigned int jresult ;
  Currency *arg1 = (Currency *) 0 ;
  bool result;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (bool)((Currency const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Currency_triangulationCurrency(void * jarg1) {
  void * jresult ;
  Currency *arg1 = (Currency *) 0 ;
  Currency *result = 0 ;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = (Currency *) &((Currency const *)arg1)->triangulationCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Currency___str__(void * jarg1) {
  char * jresult ;
  Currency *arg1 = (Currency *) 0 ;
  std::string result;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      result = Currency___str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Currency() {
  void * jresult ;
  Currency *result = 0 ;
  
  {
    try {
      result = (Currency *)new Currency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Currency(void * jarg1) {
  Currency *arg1 = (Currency *) 0 ;
  
  arg1 = (Currency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ARSCurrency() {
  void * jresult ;
  QuantLib::ARSCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ARSCurrency *)new QuantLib::ARSCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ARSCurrency(void * jarg1) {
  QuantLib::ARSCurrency *arg1 = (QuantLib::ARSCurrency *) 0 ;
  
  arg1 = (QuantLib::ARSCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ATSCurrency() {
  void * jresult ;
  QuantLib::ATSCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ATSCurrency *)new QuantLib::ATSCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ATSCurrency(void * jarg1) {
  QuantLib::ATSCurrency *arg1 = (QuantLib::ATSCurrency *) 0 ;
  
  arg1 = (QuantLib::ATSCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AUDCurrency() {
  void * jresult ;
  QuantLib::AUDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::AUDCurrency *)new QuantLib::AUDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AUDCurrency(void * jarg1) {
  QuantLib::AUDCurrency *arg1 = (QuantLib::AUDCurrency *) 0 ;
  
  arg1 = (QuantLib::AUDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BDTCurrency() {
  void * jresult ;
  QuantLib::BDTCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::BDTCurrency *)new QuantLib::BDTCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BDTCurrency(void * jarg1) {
  QuantLib::BDTCurrency *arg1 = (QuantLib::BDTCurrency *) 0 ;
  
  arg1 = (QuantLib::BDTCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BEFCurrency() {
  void * jresult ;
  QuantLib::BEFCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::BEFCurrency *)new QuantLib::BEFCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BEFCurrency(void * jarg1) {
  QuantLib::BEFCurrency *arg1 = (QuantLib::BEFCurrency *) 0 ;
  
  arg1 = (QuantLib::BEFCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BGLCurrency() {
  void * jresult ;
  QuantLib::BGLCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::BGLCurrency *)new QuantLib::BGLCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BGLCurrency(void * jarg1) {
  QuantLib::BGLCurrency *arg1 = (QuantLib::BGLCurrency *) 0 ;
  
  arg1 = (QuantLib::BGLCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BRLCurrency() {
  void * jresult ;
  QuantLib::BRLCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::BRLCurrency *)new QuantLib::BRLCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BRLCurrency(void * jarg1) {
  QuantLib::BRLCurrency *arg1 = (QuantLib::BRLCurrency *) 0 ;
  
  arg1 = (QuantLib::BRLCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BYRCurrency() {
  void * jresult ;
  QuantLib::BYRCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::BYRCurrency *)new QuantLib::BYRCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BYRCurrency(void * jarg1) {
  QuantLib::BYRCurrency *arg1 = (QuantLib::BYRCurrency *) 0 ;
  
  arg1 = (QuantLib::BYRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CADCurrency() {
  void * jresult ;
  QuantLib::CADCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::CADCurrency *)new QuantLib::CADCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CADCurrency(void * jarg1) {
  QuantLib::CADCurrency *arg1 = (QuantLib::CADCurrency *) 0 ;
  
  arg1 = (QuantLib::CADCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CHFCurrency() {
  void * jresult ;
  QuantLib::CHFCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::CHFCurrency *)new QuantLib::CHFCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CHFCurrency(void * jarg1) {
  QuantLib::CHFCurrency *arg1 = (QuantLib::CHFCurrency *) 0 ;
  
  arg1 = (QuantLib::CHFCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CLPCurrency() {
  void * jresult ;
  QuantLib::CLPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::CLPCurrency *)new QuantLib::CLPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CLPCurrency(void * jarg1) {
  QuantLib::CLPCurrency *arg1 = (QuantLib::CLPCurrency *) 0 ;
  
  arg1 = (QuantLib::CLPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CNYCurrency() {
  void * jresult ;
  QuantLib::CNYCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::CNYCurrency *)new QuantLib::CNYCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CNYCurrency(void * jarg1) {
  QuantLib::CNYCurrency *arg1 = (QuantLib::CNYCurrency *) 0 ;
  
  arg1 = (QuantLib::CNYCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_COPCurrency() {
  void * jresult ;
  QuantLib::COPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::COPCurrency *)new QuantLib::COPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_COPCurrency(void * jarg1) {
  QuantLib::COPCurrency *arg1 = (QuantLib::COPCurrency *) 0 ;
  
  arg1 = (QuantLib::COPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CYPCurrency() {
  void * jresult ;
  QuantLib::CYPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::CYPCurrency *)new QuantLib::CYPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CYPCurrency(void * jarg1) {
  QuantLib::CYPCurrency *arg1 = (QuantLib::CYPCurrency *) 0 ;
  
  arg1 = (QuantLib::CYPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CZKCurrency() {
  void * jresult ;
  QuantLib::CZKCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::CZKCurrency *)new QuantLib::CZKCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CZKCurrency(void * jarg1) {
  QuantLib::CZKCurrency *arg1 = (QuantLib::CZKCurrency *) 0 ;
  
  arg1 = (QuantLib::CZKCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DEMCurrency() {
  void * jresult ;
  QuantLib::DEMCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::DEMCurrency *)new QuantLib::DEMCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DEMCurrency(void * jarg1) {
  QuantLib::DEMCurrency *arg1 = (QuantLib::DEMCurrency *) 0 ;
  
  arg1 = (QuantLib::DEMCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DKKCurrency() {
  void * jresult ;
  QuantLib::DKKCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::DKKCurrency *)new QuantLib::DKKCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DKKCurrency(void * jarg1) {
  QuantLib::DKKCurrency *arg1 = (QuantLib::DKKCurrency *) 0 ;
  
  arg1 = (QuantLib::DKKCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EEKCurrency() {
  void * jresult ;
  QuantLib::EEKCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::EEKCurrency *)new QuantLib::EEKCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EEKCurrency(void * jarg1) {
  QuantLib::EEKCurrency *arg1 = (QuantLib::EEKCurrency *) 0 ;
  
  arg1 = (QuantLib::EEKCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ESPCurrency() {
  void * jresult ;
  QuantLib::ESPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ESPCurrency *)new QuantLib::ESPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ESPCurrency(void * jarg1) {
  QuantLib::ESPCurrency *arg1 = (QuantLib::ESPCurrency *) 0 ;
  
  arg1 = (QuantLib::ESPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURCurrency() {
  void * jresult ;
  QuantLib::EURCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::EURCurrency *)new QuantLib::EURCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURCurrency(void * jarg1) {
  QuantLib::EURCurrency *arg1 = (QuantLib::EURCurrency *) 0 ;
  
  arg1 = (QuantLib::EURCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FIMCurrency() {
  void * jresult ;
  QuantLib::FIMCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::FIMCurrency *)new QuantLib::FIMCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FIMCurrency(void * jarg1) {
  QuantLib::FIMCurrency *arg1 = (QuantLib::FIMCurrency *) 0 ;
  
  arg1 = (QuantLib::FIMCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FRFCurrency() {
  void * jresult ;
  QuantLib::FRFCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::FRFCurrency *)new QuantLib::FRFCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FRFCurrency(void * jarg1) {
  QuantLib::FRFCurrency *arg1 = (QuantLib::FRFCurrency *) 0 ;
  
  arg1 = (QuantLib::FRFCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GBPCurrency() {
  void * jresult ;
  QuantLib::GBPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::GBPCurrency *)new QuantLib::GBPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GBPCurrency(void * jarg1) {
  QuantLib::GBPCurrency *arg1 = (QuantLib::GBPCurrency *) 0 ;
  
  arg1 = (QuantLib::GBPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GRDCurrency() {
  void * jresult ;
  QuantLib::GRDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::GRDCurrency *)new QuantLib::GRDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GRDCurrency(void * jarg1) {
  QuantLib::GRDCurrency *arg1 = (QuantLib::GRDCurrency *) 0 ;
  
  arg1 = (QuantLib::GRDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HKDCurrency() {
  void * jresult ;
  QuantLib::HKDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::HKDCurrency *)new QuantLib::HKDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HKDCurrency(void * jarg1) {
  QuantLib::HKDCurrency *arg1 = (QuantLib::HKDCurrency *) 0 ;
  
  arg1 = (QuantLib::HKDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HUFCurrency() {
  void * jresult ;
  QuantLib::HUFCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::HUFCurrency *)new QuantLib::HUFCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HUFCurrency(void * jarg1) {
  QuantLib::HUFCurrency *arg1 = (QuantLib::HUFCurrency *) 0 ;
  
  arg1 = (QuantLib::HUFCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IEPCurrency() {
  void * jresult ;
  QuantLib::IEPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::IEPCurrency *)new QuantLib::IEPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IEPCurrency(void * jarg1) {
  QuantLib::IEPCurrency *arg1 = (QuantLib::IEPCurrency *) 0 ;
  
  arg1 = (QuantLib::IEPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IDRCurrency() {
  void * jresult ;
  QuantLib::IDRCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::IDRCurrency *)new QuantLib::IDRCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IDRCurrency(void * jarg1) {
  QuantLib::IDRCurrency *arg1 = (QuantLib::IDRCurrency *) 0 ;
  
  arg1 = (QuantLib::IDRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ILSCurrency() {
  void * jresult ;
  QuantLib::ILSCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ILSCurrency *)new QuantLib::ILSCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ILSCurrency(void * jarg1) {
  QuantLib::ILSCurrency *arg1 = (QuantLib::ILSCurrency *) 0 ;
  
  arg1 = (QuantLib::ILSCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_INRCurrency() {
  void * jresult ;
  QuantLib::INRCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::INRCurrency *)new QuantLib::INRCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_INRCurrency(void * jarg1) {
  QuantLib::INRCurrency *arg1 = (QuantLib::INRCurrency *) 0 ;
  
  arg1 = (QuantLib::INRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IQDCurrency() {
  void * jresult ;
  QuantLib::IQDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::IQDCurrency *)new QuantLib::IQDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IQDCurrency(void * jarg1) {
  QuantLib::IQDCurrency *arg1 = (QuantLib::IQDCurrency *) 0 ;
  
  arg1 = (QuantLib::IQDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IRRCurrency() {
  void * jresult ;
  QuantLib::IRRCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::IRRCurrency *)new QuantLib::IRRCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IRRCurrency(void * jarg1) {
  QuantLib::IRRCurrency *arg1 = (QuantLib::IRRCurrency *) 0 ;
  
  arg1 = (QuantLib::IRRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ISKCurrency() {
  void * jresult ;
  QuantLib::ISKCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ISKCurrency *)new QuantLib::ISKCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ISKCurrency(void * jarg1) {
  QuantLib::ISKCurrency *arg1 = (QuantLib::ISKCurrency *) 0 ;
  
  arg1 = (QuantLib::ISKCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ITLCurrency() {
  void * jresult ;
  QuantLib::ITLCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ITLCurrency *)new QuantLib::ITLCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ITLCurrency(void * jarg1) {
  QuantLib::ITLCurrency *arg1 = (QuantLib::ITLCurrency *) 0 ;
  
  arg1 = (QuantLib::ITLCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JPYCurrency() {
  void * jresult ;
  QuantLib::JPYCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::JPYCurrency *)new QuantLib::JPYCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JPYCurrency(void * jarg1) {
  QuantLib::JPYCurrency *arg1 = (QuantLib::JPYCurrency *) 0 ;
  
  arg1 = (QuantLib::JPYCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KRWCurrency() {
  void * jresult ;
  QuantLib::KRWCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::KRWCurrency *)new QuantLib::KRWCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KRWCurrency(void * jarg1) {
  QuantLib::KRWCurrency *arg1 = (QuantLib::KRWCurrency *) 0 ;
  
  arg1 = (QuantLib::KRWCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KWDCurrency() {
  void * jresult ;
  QuantLib::KWDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::KWDCurrency *)new QuantLib::KWDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KWDCurrency(void * jarg1) {
  QuantLib::KWDCurrency *arg1 = (QuantLib::KWDCurrency *) 0 ;
  
  arg1 = (QuantLib::KWDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LTLCurrency() {
  void * jresult ;
  QuantLib::LTLCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::LTLCurrency *)new QuantLib::LTLCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LTLCurrency(void * jarg1) {
  QuantLib::LTLCurrency *arg1 = (QuantLib::LTLCurrency *) 0 ;
  
  arg1 = (QuantLib::LTLCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LUFCurrency() {
  void * jresult ;
  QuantLib::LUFCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::LUFCurrency *)new QuantLib::LUFCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LUFCurrency(void * jarg1) {
  QuantLib::LUFCurrency *arg1 = (QuantLib::LUFCurrency *) 0 ;
  
  arg1 = (QuantLib::LUFCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LVLCurrency() {
  void * jresult ;
  QuantLib::LVLCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::LVLCurrency *)new QuantLib::LVLCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LVLCurrency(void * jarg1) {
  QuantLib::LVLCurrency *arg1 = (QuantLib::LVLCurrency *) 0 ;
  
  arg1 = (QuantLib::LVLCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MTLCurrency() {
  void * jresult ;
  QuantLib::MTLCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::MTLCurrency *)new QuantLib::MTLCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MTLCurrency(void * jarg1) {
  QuantLib::MTLCurrency *arg1 = (QuantLib::MTLCurrency *) 0 ;
  
  arg1 = (QuantLib::MTLCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MXNCurrency() {
  void * jresult ;
  QuantLib::MXNCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::MXNCurrency *)new QuantLib::MXNCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MXNCurrency(void * jarg1) {
  QuantLib::MXNCurrency *arg1 = (QuantLib::MXNCurrency *) 0 ;
  
  arg1 = (QuantLib::MXNCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MYRCurrency() {
  void * jresult ;
  QuantLib::MYRCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::MYRCurrency *)new QuantLib::MYRCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MYRCurrency(void * jarg1) {
  QuantLib::MYRCurrency *arg1 = (QuantLib::MYRCurrency *) 0 ;
  
  arg1 = (QuantLib::MYRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NLGCurrency() {
  void * jresult ;
  QuantLib::NLGCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::NLGCurrency *)new QuantLib::NLGCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NLGCurrency(void * jarg1) {
  QuantLib::NLGCurrency *arg1 = (QuantLib::NLGCurrency *) 0 ;
  
  arg1 = (QuantLib::NLGCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NOKCurrency() {
  void * jresult ;
  QuantLib::NOKCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::NOKCurrency *)new QuantLib::NOKCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NOKCurrency(void * jarg1) {
  QuantLib::NOKCurrency *arg1 = (QuantLib::NOKCurrency *) 0 ;
  
  arg1 = (QuantLib::NOKCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NPRCurrency() {
  void * jresult ;
  QuantLib::NPRCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::NPRCurrency *)new QuantLib::NPRCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NPRCurrency(void * jarg1) {
  QuantLib::NPRCurrency *arg1 = (QuantLib::NPRCurrency *) 0 ;
  
  arg1 = (QuantLib::NPRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NZDCurrency() {
  void * jresult ;
  QuantLib::NZDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::NZDCurrency *)new QuantLib::NZDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NZDCurrency(void * jarg1) {
  QuantLib::NZDCurrency *arg1 = (QuantLib::NZDCurrency *) 0 ;
  
  arg1 = (QuantLib::NZDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PEHCurrency() {
  void * jresult ;
  QuantLib::PEHCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::PEHCurrency *)new QuantLib::PEHCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PEHCurrency(void * jarg1) {
  QuantLib::PEHCurrency *arg1 = (QuantLib::PEHCurrency *) 0 ;
  
  arg1 = (QuantLib::PEHCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PEICurrency() {
  void * jresult ;
  QuantLib::PEICurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::PEICurrency *)new QuantLib::PEICurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PEICurrency(void * jarg1) {
  QuantLib::PEICurrency *arg1 = (QuantLib::PEICurrency *) 0 ;
  
  arg1 = (QuantLib::PEICurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PENCurrency() {
  void * jresult ;
  QuantLib::PENCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::PENCurrency *)new QuantLib::PENCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PENCurrency(void * jarg1) {
  QuantLib::PENCurrency *arg1 = (QuantLib::PENCurrency *) 0 ;
  
  arg1 = (QuantLib::PENCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PKRCurrency() {
  void * jresult ;
  QuantLib::PKRCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::PKRCurrency *)new QuantLib::PKRCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PKRCurrency(void * jarg1) {
  QuantLib::PKRCurrency *arg1 = (QuantLib::PKRCurrency *) 0 ;
  
  arg1 = (QuantLib::PKRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PLNCurrency() {
  void * jresult ;
  QuantLib::PLNCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::PLNCurrency *)new QuantLib::PLNCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PLNCurrency(void * jarg1) {
  QuantLib::PLNCurrency *arg1 = (QuantLib::PLNCurrency *) 0 ;
  
  arg1 = (QuantLib::PLNCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PTECurrency() {
  void * jresult ;
  QuantLib::PTECurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::PTECurrency *)new QuantLib::PTECurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PTECurrency(void * jarg1) {
  QuantLib::PTECurrency *arg1 = (QuantLib::PTECurrency *) 0 ;
  
  arg1 = (QuantLib::PTECurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ROLCurrency() {
  void * jresult ;
  QuantLib::ROLCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ROLCurrency *)new QuantLib::ROLCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ROLCurrency(void * jarg1) {
  QuantLib::ROLCurrency *arg1 = (QuantLib::ROLCurrency *) 0 ;
  
  arg1 = (QuantLib::ROLCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RONCurrency() {
  void * jresult ;
  QuantLib::RONCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::RONCurrency *)new QuantLib::RONCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RONCurrency(void * jarg1) {
  QuantLib::RONCurrency *arg1 = (QuantLib::RONCurrency *) 0 ;
  
  arg1 = (QuantLib::RONCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RUBCurrency() {
  void * jresult ;
  QuantLib::RUBCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::RUBCurrency *)new QuantLib::RUBCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RUBCurrency(void * jarg1) {
  QuantLib::RUBCurrency *arg1 = (QuantLib::RUBCurrency *) 0 ;
  
  arg1 = (QuantLib::RUBCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SARCurrency() {
  void * jresult ;
  QuantLib::SARCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::SARCurrency *)new QuantLib::SARCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SARCurrency(void * jarg1) {
  QuantLib::SARCurrency *arg1 = (QuantLib::SARCurrency *) 0 ;
  
  arg1 = (QuantLib::SARCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SEKCurrency() {
  void * jresult ;
  QuantLib::SEKCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::SEKCurrency *)new QuantLib::SEKCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SEKCurrency(void * jarg1) {
  QuantLib::SEKCurrency *arg1 = (QuantLib::SEKCurrency *) 0 ;
  
  arg1 = (QuantLib::SEKCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SGDCurrency() {
  void * jresult ;
  QuantLib::SGDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::SGDCurrency *)new QuantLib::SGDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SGDCurrency(void * jarg1) {
  QuantLib::SGDCurrency *arg1 = (QuantLib::SGDCurrency *) 0 ;
  
  arg1 = (QuantLib::SGDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SITCurrency() {
  void * jresult ;
  QuantLib::SITCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::SITCurrency *)new QuantLib::SITCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SITCurrency(void * jarg1) {
  QuantLib::SITCurrency *arg1 = (QuantLib::SITCurrency *) 0 ;
  
  arg1 = (QuantLib::SITCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SKKCurrency() {
  void * jresult ;
  QuantLib::SKKCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::SKKCurrency *)new QuantLib::SKKCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SKKCurrency(void * jarg1) {
  QuantLib::SKKCurrency *arg1 = (QuantLib::SKKCurrency *) 0 ;
  
  arg1 = (QuantLib::SKKCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_THBCurrency() {
  void * jresult ;
  QuantLib::THBCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::THBCurrency *)new QuantLib::THBCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_THBCurrency(void * jarg1) {
  QuantLib::THBCurrency *arg1 = (QuantLib::THBCurrency *) 0 ;
  
  arg1 = (QuantLib::THBCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TRLCurrency() {
  void * jresult ;
  QuantLib::TRLCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::TRLCurrency *)new QuantLib::TRLCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TRLCurrency(void * jarg1) {
  QuantLib::TRLCurrency *arg1 = (QuantLib::TRLCurrency *) 0 ;
  
  arg1 = (QuantLib::TRLCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TRYCurrency() {
  void * jresult ;
  QuantLib::TRYCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::TRYCurrency *)new QuantLib::TRYCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TRYCurrency(void * jarg1) {
  QuantLib::TRYCurrency *arg1 = (QuantLib::TRYCurrency *) 0 ;
  
  arg1 = (QuantLib::TRYCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TTDCurrency() {
  void * jresult ;
  QuantLib::TTDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::TTDCurrency *)new QuantLib::TTDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TTDCurrency(void * jarg1) {
  QuantLib::TTDCurrency *arg1 = (QuantLib::TTDCurrency *) 0 ;
  
  arg1 = (QuantLib::TTDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TWDCurrency() {
  void * jresult ;
  QuantLib::TWDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::TWDCurrency *)new QuantLib::TWDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TWDCurrency(void * jarg1) {
  QuantLib::TWDCurrency *arg1 = (QuantLib::TWDCurrency *) 0 ;
  
  arg1 = (QuantLib::TWDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USDCurrency() {
  void * jresult ;
  QuantLib::USDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::USDCurrency *)new QuantLib::USDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_USDCurrency(void * jarg1) {
  QuantLib::USDCurrency *arg1 = (QuantLib::USDCurrency *) 0 ;
  
  arg1 = (QuantLib::USDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VEBCurrency() {
  void * jresult ;
  QuantLib::VEBCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::VEBCurrency *)new QuantLib::VEBCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VEBCurrency(void * jarg1) {
  QuantLib::VEBCurrency *arg1 = (QuantLib::VEBCurrency *) 0 ;
  
  arg1 = (QuantLib::VEBCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VNDCurrency() {
  void * jresult ;
  QuantLib::VNDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::VNDCurrency *)new QuantLib::VNDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VNDCurrency(void * jarg1) {
  QuantLib::VNDCurrency *arg1 = (QuantLib::VNDCurrency *) 0 ;
  
  arg1 = (QuantLib::VNDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZARCurrency() {
  void * jresult ;
  QuantLib::ZARCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ZARCurrency *)new QuantLib::ZARCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZARCurrency(void * jarg1) {
  QuantLib::ZARCurrency *arg1 = (QuantLib::ZARCurrency *) 0 ;
  
  arg1 = (QuantLib::ZARCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolation(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeLinearInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeLinearInterpolation *)new SafeLinearInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LinearInterpolation_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLinearInterpolation *arg1 = (SafeLinearInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLinearInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LinearInterpolation_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLinearInterpolation *arg1 = (SafeLinearInterpolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLinearInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LinearInterpolation(void * jarg1) {
  SafeLinearInterpolation *arg1 = (SafeLinearInterpolation *) 0 ;
  
  arg1 = (SafeLinearInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogLinearInterpolation(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeLogLinearInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeLogLinearInterpolation *)new SafeLogLinearInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogLinearInterpolation_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogLinearInterpolation *arg1 = (SafeLogLinearInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogLinearInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogLinearInterpolation_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogLinearInterpolation *arg1 = (SafeLogLinearInterpolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogLinearInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogLinearInterpolation(void * jarg1) {
  SafeLogLinearInterpolation *arg1 = (SafeLogLinearInterpolation *) 0 ;
  
  arg1 = (SafeLogLinearInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BackwardFlatInterpolation(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeBackwardFlatInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeBackwardFlatInterpolation *)new SafeBackwardFlatInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BackwardFlatInterpolation_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeBackwardFlatInterpolation *arg1 = (SafeBackwardFlatInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeBackwardFlatInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BackwardFlatInterpolation_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeBackwardFlatInterpolation *arg1 = (SafeBackwardFlatInterpolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeBackwardFlatInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BackwardFlatInterpolation(void * jarg1) {
  SafeBackwardFlatInterpolation *arg1 = (SafeBackwardFlatInterpolation *) 0 ;
  
  arg1 = (SafeBackwardFlatInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardFlatInterpolation(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeForwardFlatInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeForwardFlatInterpolation *)new SafeForwardFlatInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ForwardFlatInterpolation_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeForwardFlatInterpolation *arg1 = (SafeForwardFlatInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeForwardFlatInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ForwardFlatInterpolation_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeForwardFlatInterpolation *arg1 = (SafeForwardFlatInterpolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeForwardFlatInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardFlatInterpolation(void * jarg1) {
  SafeForwardFlatInterpolation *arg1 = (SafeForwardFlatInterpolation *) 0 ;
  
  arg1 = (SafeForwardFlatInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicNaturalSpline(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeCubicNaturalSpline *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeCubicNaturalSpline *)new SafeCubicNaturalSpline((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicNaturalSpline_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicNaturalSpline_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicNaturalSpline_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeCubicNaturalSpline_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicNaturalSpline_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeCubicNaturalSpline_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicNaturalSpline_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicNaturalSpline_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicNaturalSpline_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeCubicNaturalSpline_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicNaturalSpline_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeCubicNaturalSpline_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CubicNaturalSpline(void * jarg1) {
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  
  arg1 = (SafeCubicNaturalSpline *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogCubicNaturalSpline(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeLogCubicNaturalSpline *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeLogCubicNaturalSpline *)new SafeLogCubicNaturalSpline((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogCubicNaturalSpline_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogCubicNaturalSpline_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogCubicNaturalSpline_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogCubicNaturalSpline_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogCubicNaturalSpline_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogCubicNaturalSpline_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogCubicNaturalSpline_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogCubicNaturalSpline_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogCubicNaturalSpline(void * jarg1) {
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  
  arg1 = (SafeLogCubicNaturalSpline *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicNaturalSpline(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeMonotonicCubicNaturalSpline *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeMonotonicCubicNaturalSpline *)new SafeMonotonicCubicNaturalSpline((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicCubicNaturalSpline_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicCubicNaturalSpline_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicCubicNaturalSpline_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicCubicNaturalSpline_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicCubicNaturalSpline_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicCubicNaturalSpline_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicCubicNaturalSpline_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicCubicNaturalSpline_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicCubicNaturalSpline(void * jarg1) {
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  
  arg1 = (SafeMonotonicCubicNaturalSpline *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicLogCubicNaturalSpline(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeMonotonicLogCubicNaturalSpline *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeMonotonicLogCubicNaturalSpline *)new SafeMonotonicLogCubicNaturalSpline((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicNaturalSpline_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicNaturalSpline_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicNaturalSpline_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicNaturalSpline_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicNaturalSpline_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicNaturalSpline_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicNaturalSpline_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicLogCubicNaturalSpline(void * jarg1) {
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  
  arg1 = (SafeMonotonicLogCubicNaturalSpline *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerCubic(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeKrugerCubic *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeKrugerCubic *)new SafeKrugerCubic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerCubic_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerCubic_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerCubic_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeKrugerCubic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerCubic_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeKrugerCubic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerCubic_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeKrugerCubic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerCubic_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeKrugerCubic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerCubic_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeKrugerCubic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerCubic_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeKrugerCubic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KrugerCubic(void * jarg1) {
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  
  arg1 = (SafeKrugerCubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerLogCubic(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeKrugerLogCubic *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeKrugerLogCubic *)new SafeKrugerLogCubic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerLogCubic_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerLogCubic_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerLogCubic_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeKrugerLogCubic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerLogCubic_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeKrugerLogCubic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerLogCubic_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeKrugerLogCubic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerLogCubic_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeKrugerLogCubic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerLogCubic_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeKrugerLogCubic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_KrugerLogCubic_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeKrugerLogCubic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KrugerLogCubic(void * jarg1) {
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  
  arg1 = (SafeKrugerLogCubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FritschButlandCubic(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeFritschButlandCubic *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeFritschButlandCubic *)new SafeFritschButlandCubic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandCubic_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandCubic_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandCubic_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeFritschButlandCubic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandCubic_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeFritschButlandCubic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandCubic_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeFritschButlandCubic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandCubic_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeFritschButlandCubic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandCubic_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeFritschButlandCubic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandCubic_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeFritschButlandCubic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FritschButlandCubic(void * jarg1) {
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  
  arg1 = (SafeFritschButlandCubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FritschButlandLogCubic(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeFritschButlandLogCubic *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeFritschButlandLogCubic *)new SafeFritschButlandLogCubic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandLogCubic_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandLogCubic_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandLogCubic_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandLogCubic_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandLogCubic_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandLogCubic_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandLogCubic_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FritschButlandLogCubic_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FritschButlandLogCubic(void * jarg1) {
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  
  arg1 = (SafeFritschButlandLogCubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Parabolic(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeParabolic *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeParabolic *)new SafeParabolic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parabolic_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parabolic_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parabolic_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeParabolic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parabolic_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeParabolic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parabolic_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeParabolic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parabolic_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeParabolic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parabolic_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeParabolic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parabolic_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeParabolic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Parabolic(void * jarg1) {
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  
  arg1 = (SafeParabolic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogParabolic(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeLogParabolic *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeLogParabolic *)new SafeLogParabolic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogParabolic_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogParabolic_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogParabolic_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeLogParabolic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogParabolic_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeLogParabolic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogParabolic_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeLogParabolic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogParabolic_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeLogParabolic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogParabolic_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeLogParabolic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LogParabolic_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeLogParabolic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogParabolic(void * jarg1) {
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  
  arg1 = (SafeLogParabolic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicParabolic(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeMonotonicParabolic *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeMonotonicParabolic *)new SafeMonotonicParabolic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicParabolic_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicParabolic_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicParabolic_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicParabolic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicParabolic_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicParabolic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicParabolic_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicParabolic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicParabolic_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicParabolic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicParabolic_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicParabolic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicParabolic_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicParabolic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicParabolic(void * jarg1) {
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  
  arg1 = (SafeMonotonicParabolic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicLogParabolic(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeMonotonicLogParabolic *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeMonotonicLogParabolic *)new SafeMonotonicLogParabolic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogParabolic_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogParabolic_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogParabolic_derivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogParabolic_derivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogParabolic_secondDerivative__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogParabolic_secondDerivative__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogParabolic_primitive__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MonotonicLogParabolic_primitive__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicLogParabolic(void * jarg1) {
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  
  arg1 = (SafeMonotonicLogParabolic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BilinearInterpolation(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Matrix *arg3 = 0 ;
  SafeBilinearInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (Matrix *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeBilinearInterpolation *)new SafeBilinearInterpolation((Array const &)*arg1,(Array const &)*arg2,(Matrix const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BilinearInterpolation_call__SWIG_0(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  SafeBilinearInterpolation *arg1 = (SafeBilinearInterpolation *) 0 ;
  Real arg2 ;
  Real arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (SafeBilinearInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BilinearInterpolation_call__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  SafeBilinearInterpolation *arg1 = (SafeBilinearInterpolation *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (SafeBilinearInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BilinearInterpolation(void * jarg1) {
  SafeBilinearInterpolation *arg1 = (SafeBilinearInterpolation *) 0 ;
  
  arg1 = (SafeBilinearInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BicubicSpline(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Matrix *arg3 = 0 ;
  SafeBicubicSpline *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (Matrix *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeBicubicSpline *)new SafeBicubicSpline((Array const &)*arg1,(Array const &)*arg2,(Matrix const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BicubicSpline_call__SWIG_0(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  SafeBicubicSpline *arg1 = (SafeBicubicSpline *) 0 ;
  Real arg2 ;
  Real arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (SafeBicubicSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BicubicSpline_call__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  SafeBicubicSpline *arg1 = (SafeBicubicSpline *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (SafeBicubicSpline *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BicubicSpline(void * jarg1) {
  SafeBicubicSpline *arg1 = (SafeBicubicSpline *) 0 ;
  
  arg1 = (SafeBicubicSpline *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BackwardFlat() {
  void * jresult ;
  BackwardFlat *result = 0 ;
  
  {
    try {
      result = (BackwardFlat *)new BackwardFlat();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BackwardFlat(void * jarg1) {
  BackwardFlat *arg1 = (BackwardFlat *) 0 ;
  
  arg1 = (BackwardFlat *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardFlat() {
  void * jresult ;
  ForwardFlat *result = 0 ;
  
  {
    try {
      result = (ForwardFlat *)new ForwardFlat();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardFlat(void * jarg1) {
  ForwardFlat *arg1 = (ForwardFlat *) 0 ;
  
  arg1 = (ForwardFlat *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Linear() {
  void * jresult ;
  Linear *result = 0 ;
  
  {
    try {
      result = (Linear *)new Linear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Linear(void * jarg1) {
  Linear *arg1 = (Linear *) 0 ;
  
  arg1 = (Linear *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogLinear() {
  void * jresult ;
  LogLinear *result = 0 ;
  
  {
    try {
      result = (LogLinear *)new LogLinear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogLinear(void * jarg1) {
  LogLinear *arg1 = (LogLinear *) 0 ;
  
  arg1 = (LogLinear *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Cubic() {
  void * jresult ;
  Cubic *result = 0 ;
  
  {
    try {
      result = (Cubic *)new Cubic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Cubic(void * jarg1) {
  Cubic *arg1 = (Cubic *) 0 ;
  
  arg1 = (Cubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubic() {
  void * jresult ;
  MonotonicCubic *result = 0 ;
  
  {
    try {
      result = (MonotonicCubic *)new MonotonicCubic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicCubic(void * jarg1) {
  MonotonicCubic *arg1 = (MonotonicCubic *) 0 ;
  
  arg1 = (MonotonicCubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultLogCubic() {
  void * jresult ;
  DefaultLogCubic *result = 0 ;
  
  {
    try {
      result = (DefaultLogCubic *)new DefaultLogCubic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DefaultLogCubic(void * jarg1) {
  DefaultLogCubic *arg1 = (DefaultLogCubic *) 0 ;
  
  arg1 = (DefaultLogCubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicLogCubic() {
  void * jresult ;
  MonotonicLogCubic *result = 0 ;
  
  {
    try {
      result = (MonotonicLogCubic *)new MonotonicLogCubic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicLogCubic(void * jarg1) {
  MonotonicLogCubic *arg1 = (MonotonicLogCubic *) 0 ;
  
  arg1 = (MonotonicLogCubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  YieldTermStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (YieldTermStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_YieldTermStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_YieldTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YieldTermStructure() {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< YieldTermStructure > *)new boost::shared_ptr< YieldTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YieldTermStructure(void * jarg1) {
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_referenceDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_maxDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_maxTime(void * jarg1) {
  double jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_discount__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  DiscountFactor result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (DiscountFactor)(*arg1)->discount((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_discount__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DiscountFactor result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountFactor)(*arg1)->discount((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_discount__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  DiscountFactor result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (DiscountFactor)(*arg1)->discount(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_discount__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time arg2 ;
  DiscountFactor result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)(*arg1)->discount(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_3(void * jarg1, double jarg2, int jarg3, int jarg4, unsigned int jarg5) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  bool arg5 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_4(void * jarg1, double jarg2, int jarg3, int jarg4) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_5(void * jarg1, double jarg2, int jarg3) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_3(void * jarg1, double jarg2, double jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_4(void * jarg1, double jarg2, double jarg3, int jarg4, int jarg5) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_5(void * jarg1, double jarg2, double jarg3, int jarg4) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  InterestRate result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = (boost::shared_ptr< YieldTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YieldTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< YieldTermStructure > *)new Handle< YieldTermStructure >((boost::shared_ptr< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YieldTermStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< YieldTermStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< YieldTermStructure > *)new Handle< YieldTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  boost::shared_ptr< YieldTermStructure > result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< YieldTermStructure >((const boost::shared_ptr< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_YieldTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YieldTermStructureHandle(void * jarg1) {
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_discount__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  DiscountFactor result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (DiscountFactor)(*arg1)->discount((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_discount__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DiscountFactor result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountFactor)(*arg1)->discount((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_discount__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  DiscountFactor result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (DiscountFactor)(*arg1)->discount(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_discount__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  DiscountFactor result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)(*arg1)->discount(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_zeroRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_zeroRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_zeroRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_zeroRate__SWIG_3(void * jarg1, double jarg2, int jarg3, int jarg4, unsigned int jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  bool arg5 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_zeroRate__SWIG_4(void * jarg1, double jarg2, int jarg3, int jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_zeroRate__SWIG_5(void * jarg1, double jarg2, int jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_forwardRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_forwardRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_forwardRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_forwardRate__SWIG_3(void * jarg1, double jarg2, double jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_forwardRate__SWIG_4(void * jarg1, double jarg2, double jarg3, int jarg4, int jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_forwardRate__SWIG_5(void * jarg1, double jarg2, double jarg3, int jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  InterestRate result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableYieldTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  RelinkableHandle< YieldTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< YieldTermStructure > *)new RelinkableHandle< YieldTermStructure >((boost::shared_ptr< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableYieldTermStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< YieldTermStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< YieldTermStructure > *)new RelinkableHandle< YieldTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableYieldTermStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< YieldTermStructure > *arg1 = (RelinkableHandle< YieldTermStructure > *) 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< YieldTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableYieldTermStructureHandle(void * jarg1) {
  RelinkableHandle< YieldTermStructure > *arg1 = (RelinkableHandle< YieldTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< YieldTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ImpliedTermStructure(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Date *arg2 = 0 ;
  ImpliedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ImpliedTermStructurePtr *)new_ImpliedTermStructurePtr((Handle< YieldTermStructure > const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ImpliedTermStructure(void * jarg1) {
  ImpliedTermStructurePtr *arg1 = (ImpliedTermStructurePtr *) 0 ;
  
  arg1 = (ImpliedTermStructurePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroSpreadedTermStructure__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, void * jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  ZeroSpreadedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroSpreadedTermStructurePtr *)new_ZeroSpreadedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroSpreadedTermStructure__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  ZeroSpreadedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (ZeroSpreadedTermStructurePtr *)new_ZeroSpreadedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroSpreadedTermStructure__SWIG_2(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Compounding arg3 ;
  ZeroSpreadedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  {
    try {
      result = (ZeroSpreadedTermStructurePtr *)new_ZeroSpreadedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroSpreadedTermStructure__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ZeroSpreadedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroSpreadedTermStructurePtr *)new_ZeroSpreadedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroSpreadedTermStructure(void * jarg1) {
  ZeroSpreadedTermStructurePtr *arg1 = (ZeroSpreadedTermStructurePtr *) 0 ;
  
  arg1 = (ZeroSpreadedTermStructurePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardSpreadedTermStructure(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ForwardSpreadedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardSpreadedTermStructurePtr *)new_ForwardSpreadedTermStructurePtr((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardSpreadedTermStructure(void * jarg1) {
  ForwardSpreadedTermStructurePtr *arg1 = (ForwardSpreadedTermStructurePtr *) 0 ;
  
  arg1 = (ForwardSpreadedTermStructurePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_0(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote > > *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  DayCounter *arg6 = 0 ;
  Linear *arg7 = 0 ;
  SpreadedLinearZeroInterpolatedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructurePtr *)new_SpreadedLinearZeroInterpolatedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote > > const &)*arg2,(std::vector< Date > const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(Linear const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote > > *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  DayCounter *arg6 = 0 ;
  SpreadedLinearZeroInterpolatedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructurePtr *)new_SpreadedLinearZeroInterpolatedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote > > const &)*arg2,(std::vector< Date > const &)*arg3,arg4,arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_2(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote > > *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  SpreadedLinearZeroInterpolatedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructurePtr *)new_SpreadedLinearZeroInterpolatedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote > > const &)*arg2,(std::vector< Date > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_3(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote > > *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  Compounding arg4 ;
  SpreadedLinearZeroInterpolatedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructurePtr *)new_SpreadedLinearZeroInterpolatedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote > > const &)*arg2,(std::vector< Date > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote > > *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  SpreadedLinearZeroInterpolatedTermStructurePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructurePtr *)new_SpreadedLinearZeroInterpolatedTermStructurePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote > > const &)*arg2,(std::vector< Date > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SpreadedLinearZeroInterpolatedTermStructure(void * jarg1) {
  SpreadedLinearZeroInterpolatedTermStructurePtr *arg1 = (SpreadedLinearZeroInterpolatedTermStructurePtr *) 0 ;
  
  arg1 = (SpreadedLinearZeroInterpolatedTermStructurePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_0(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_0((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_0((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_0((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_3((Date const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_3((Date const &)*arg1,arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_5(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_3((Date const &)*arg1,arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_6(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_6(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_6(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_9(int jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_9(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_10(int jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_9(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatForward__SWIG_11(int jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  FlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatForwardPtr *)new_FlatForwardPtr__SWIG_9(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FlatForward(void * jarg1) {
  FlatForwardPtr *arg1 = (FlatForwardPtr *) 0 ;
  
  arg1 = (FlatForwardPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RealTimeSeries__SWIG_0() {
  void * jresult ;
  TimeSeries< Real > *result = 0 ;
  
  {
    try {
      result = (TimeSeries< Real > *)new TimeSeries< Real >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RealTimeSeries__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  TimeSeries< Real > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TimeSeries< Real > *)new_TimeSeries_Sl_Real_Sg___SWIG_1((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RealTimeSeries_dates(void * jarg1) {
  void * jresult ;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  std::vector< Date > result;
  
  arg1 = (TimeSeries< Real > *)jarg1; 
  {
    try {
      result = (arg1)->dates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Date >((const std::vector< Date > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RealTimeSeries_values(void * jarg1) {
  void * jresult ;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  std::vector< double > result;
  
  arg1 = (TimeSeries< Real > *)jarg1; 
  {
    try {
      result = (arg1)->values();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< double >((const std::vector< double > &)result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_RealTimeSeries_size(void * jarg1) {
  unsigned long jresult ;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  Size result;
  
  arg1 = (TimeSeries< Real > *)jarg1; 
  {
    try {
      result = (arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RealTimeSeries(void * jarg1) {
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  
  arg1 = (TimeSeries< Real > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntervalPriceTimeSeries__SWIG_0() {
  void * jresult ;
  TimeSeries< IntervalPrice > *result = 0 ;
  
  {
    try {
      result = (TimeSeries< IntervalPrice > *)new TimeSeries< IntervalPrice >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntervalPriceTimeSeries__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< IntervalPrice > *arg2 = 0 ;
  TimeSeries< IntervalPrice > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< IntervalPrice > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TimeSeries< IntervalPrice > *)new_TimeSeries_Sl_IntervalPrice_Sg___SWIG_1((std::vector< Date > const &)*arg1,(std::vector< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPriceTimeSeries_dates(void * jarg1) {
  void * jresult ;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  std::vector< Date > result;
  
  arg1 = (TimeSeries< IntervalPrice > *)jarg1; 
  {
    try {
      result = (arg1)->dates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Date >((const std::vector< Date > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPriceTimeSeries_values(void * jarg1) {
  void * jresult ;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice > result;
  
  arg1 = (TimeSeries< IntervalPrice > *)jarg1; 
  {
    try {
      result = (arg1)->values();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< IntervalPrice >((const std::vector< IntervalPrice > &)result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_IntervalPriceTimeSeries_size(void * jarg1) {
  unsigned long jresult ;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  Size result;
  
  arg1 = (TimeSeries< IntervalPrice > *)jarg1; 
  {
    try {
      result = (arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IntervalPriceTimeSeries(void * jarg1) {
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  
  arg1 = (TimeSeries< IntervalPrice > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_Clear(void * jarg1) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_Add(void * jarg1, void * jarg2) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  IntervalPrice *arg2 = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (IntervalPrice *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IntervalPrice const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((IntervalPrice const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::size_type result;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  {
    try {
      result = ((std::vector< IntervalPrice > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::size_type result;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  {
    try {
      result = ((std::vector< IntervalPrice > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::size_type arg2 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (std::vector< IntervalPrice >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntervalPriceVector__SWIG_0() {
  void * jresult ;
  std::vector< IntervalPrice > *result = 0 ;
  
  {
    try {
      result = (std::vector< IntervalPrice > *)new std::vector< IntervalPrice >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntervalPriceVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< IntervalPrice > *arg1 = 0 ;
  std::vector< IntervalPrice > *result = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< IntervalPrice > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< IntervalPrice > *)new std::vector< IntervalPrice >((std::vector< IntervalPrice > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntervalPriceVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< IntervalPrice > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< IntervalPrice > *)new_std_vector_Sl_IntervalPrice_Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  SwigValueWrapper< IntervalPrice > result;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_IntervalPrice_Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new IntervalPrice((const IntervalPrice &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  IntervalPrice *result = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (IntervalPrice *) &std_vector_Sl_IntervalPrice_Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  IntervalPrice *arg3 = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (IntervalPrice *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IntervalPrice const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg__setitem(arg1,arg2,(IntervalPrice const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice > *arg2 = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (std::vector< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< IntervalPrice > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_IntervalPrice_Sg__AddRange(arg1,(std::vector< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< IntervalPrice > *result = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< IntervalPrice > *)std_vector_Sl_IntervalPrice_Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  IntervalPrice *arg3 = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (IntervalPrice *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IntervalPrice const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg__Insert(arg1,arg2,(IntervalPrice const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  std::vector< IntervalPrice > *arg3 = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< IntervalPrice > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< IntervalPrice > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg__InsertRange(arg1,arg2,(std::vector< IntervalPrice > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  IntervalPrice *arg1 = 0 ;
  int arg2 ;
  std::vector< IntervalPrice > *result = 0 ;
  
  arg1 = (IntervalPrice *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IntervalPrice const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< IntervalPrice > *)std_vector_Sl_IntervalPrice_Sg__Repeat((IntervalPrice const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  {
    try {
      std_vector_Sl_IntervalPrice_Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPriceVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  int arg2 ;
  std::vector< IntervalPrice > *arg3 = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< IntervalPrice > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< IntervalPrice > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg__SetRange(arg1,arg2,(std::vector< IntervalPrice > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IntervalPriceVector(void * jarg1) {
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntervalPrice(double jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  IntervalPrice *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (IntervalPrice *)new IntervalPrice(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPrice_setValue(void * jarg1, double jarg2, int jarg3) {
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  Real arg2 ;
  IntervalPrice::Type arg3 ;
  
  arg1 = (IntervalPrice *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (IntervalPrice::Type)jarg3; 
  {
    try {
      (arg1)->setValue(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IntervalPrice_setValues(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  
  arg1 = (IntervalPrice *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      (arg1)->setValues(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IntervalPrice_value(void * jarg1, int jarg2) {
  double jresult ;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  IntervalPrice::Type arg2 ;
  Real result;
  
  arg1 = (IntervalPrice *)jarg1; 
  arg2 = (IntervalPrice::Type)jarg2; 
  {
    try {
      result = (Real)(arg1)->value(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IntervalPrice_open(void * jarg1) {
  double jresult ;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  Real result;
  
  arg1 = (IntervalPrice *)jarg1; 
  {
    try {
      result = (Real)(arg1)->open();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IntervalPrice_close(void * jarg1) {
  double jresult ;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  Real result;
  
  arg1 = (IntervalPrice *)jarg1; 
  {
    try {
      result = (Real)(arg1)->close();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IntervalPrice_high(void * jarg1) {
  double jresult ;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  Real result;
  
  arg1 = (IntervalPrice *)jarg1; 
  {
    try {
      result = (Real)(arg1)->high();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IntervalPrice_low(void * jarg1) {
  double jresult ;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  Real result;
  
  arg1 = (IntervalPrice *)jarg1; 
  {
    try {
      result = (Real)(arg1)->low();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPrice_makeSeries(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  TimeSeries< IntervalPrice > result;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = IntervalPrice::makeSeries((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,(std::vector< double > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< IntervalPrice >((const TimeSeries< IntervalPrice > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPrice_extractValues(void * jarg1, int jarg2) {
  void * jresult ;
  TimeSeries< IntervalPrice > arg1 ;
  IntervalPrice::Type arg2 ;
  TimeSeries< IntervalPrice > *argp1 ;
  std::vector< Real > result;
  
  argp1 = (TimeSeries< IntervalPrice > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null TimeSeries< IntervalPrice >", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (IntervalPrice::Type)jarg2; 
  {
    try {
      result = IntervalPrice::extractValues(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IntervalPrice_extractComponent(void * jarg1, int jarg2) {
  void * jresult ;
  TimeSeries< IntervalPrice > arg1 ;
  IntervalPrice::Type arg2 ;
  TimeSeries< IntervalPrice > *argp1 ;
  TimeSeries< Real > result;
  
  argp1 = (TimeSeries< IntervalPrice > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null TimeSeries< IntervalPrice >", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (IntervalPrice::Type)jarg2; 
  {
    try {
      result = IntervalPrice::extractComponent(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< Real >((const TimeSeries< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IntervalPrice(void * jarg1) {
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  
  arg1 = (IntervalPrice *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IndexManager_instance() {
  void * jresult ;
  IndexManager *result = 0 ;
  
  {
    try {
      result = (IndexManager *) &IndexManager::instance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IndexManager_setHistory(void * jarg1, char * jarg2, void * jarg3) {
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  TimeSeries< Real > *arg3 = 0 ;
  
  arg1 = (IndexManager *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (TimeSeries< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeSeries< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setHistory((std::string const &)*arg2,(TimeSeries< Real > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IndexManager_getHistory(void * jarg1, char * jarg2) {
  void * jresult ;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  TimeSeries< Real > *result = 0 ;
  
  arg1 = (IndexManager *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (TimeSeries< Real > *) &((IndexManager const *)arg1)->getHistory((std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IndexManager_hasHistory(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (IndexManager *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (bool)((IndexManager const *)arg1)->hasHistory((std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IndexManager_histories(void * jarg1) {
  void * jresult ;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::vector< std::string > result;
  
  arg1 = (IndexManager *)jarg1; 
  {
    try {
      result = ((IndexManager const *)arg1)->histories();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IndexManager_clearHistory(void * jarg1, char * jarg2) {
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (IndexManager *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->clearHistory((std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IndexManager_clearHistories(void * jarg1) {
  IndexManager *arg1 = (IndexManager *) 0 ;
  
  arg1 = (IndexManager *)jarg1; 
  {
    try {
      (arg1)->clearHistories();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IndexManager(void * jarg1) {
  IndexManager *arg1 = (IndexManager *) 0 ;
  
  arg1 = (IndexManager *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Index___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  Index *result = 0 ;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  {
    try {
      result = (Index *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Index_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Index_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Index_addFixings(void * jarg1, void * jarg2, void * jarg3) {
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return ;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return ;
  } 
  {
    try {
      boost_shared_ptr_Sl_Index_Sg__addFixings(arg1,(std::vector< Date > const &)*arg2,(std::vector< double > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Index___str__(void * jarg1) {
  char * jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  std::string result;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_Index_Sg____str__(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Index_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_Index_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Index() {
  void * jresult ;
  boost::shared_ptr< Index > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Index > *)new boost::shared_ptr< Index >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Index(void * jarg1) {
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Index_name(void * jarg1) {
  char * jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  std::string result;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  {
    try {
      result = (*arg1)->name();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Index_fixingCalendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  {
    try {
      result = (*arg1)->fixingCalendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Index_isValidFixingDate(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  Date *arg2 = 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)(*arg1)->isValidFixingDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Index_fixing__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->fixing((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Index_fixing__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->fixing((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Index_addFixing(void * jarg1, void * jarg2, double jarg3) {
  boost::shared_ptr< Index > *arg1 = (boost::shared_ptr< Index > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  
  arg1 = (boost::shared_ptr< Index > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      (*arg1)->addFixing((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_familyName(void * jarg1) {
  char * jresult ;
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  std::string result;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  {
    try {
      result = InterestRateIndexPtr_familyName(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_tenor(void * jarg1) {
  void * jresult ;
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  Period result;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  {
    try {
      result = InterestRateIndexPtr_tenor(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_fixingDays(void * jarg1) {
  unsigned int jresult ;
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  Natural result;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  {
    try {
      result = (Natural)InterestRateIndexPtr_fixingDays(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_fixingDate(void * jarg1, void * jarg2) {
  void * jresult ;
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = InterestRateIndexPtr_fixingDate(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_currency(void * jarg1) {
  void * jresult ;
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  Currency result;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  {
    try {
      result = InterestRateIndexPtr_currency(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Currency((const Currency &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_dayCounter(void * jarg1) {
  void * jresult ;
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  {
    try {
      result = InterestRateIndexPtr_dayCounter(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_maturityDate(void * jarg1, void * jarg2) {
  void * jresult ;
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = InterestRateIndexPtr_maturityDate(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_valueDate(void * jarg1, void * jarg2) {
  void * jresult ;
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = InterestRateIndexPtr_valueDate(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InterestRateIndex(void * jarg1) {
  InterestRateIndexPtr *arg1 = (InterestRateIndexPtr *) 0 ;
  
  arg1 = (InterestRateIndexPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborIndex__SWIG_0(char * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  IborIndexPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborIndexPtr *)new_IborIndexPtr__SWIG_0((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8,(Handle< YieldTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborIndex__SWIG_1(char * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  IborIndexPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborIndexPtr *)new_IborIndexPtr__SWIG_0((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_IborIndex_businessDayConvention(void * jarg1) {
  int jresult ;
  IborIndexPtr *arg1 = (IborIndexPtr *) 0 ;
  BusinessDayConvention result;
  
  arg1 = (IborIndexPtr *)jarg1; 
  {
    try {
      result = (BusinessDayConvention)IborIndexPtr_businessDayConvention(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IborIndex_endOfMonth(void * jarg1) {
  unsigned int jresult ;
  IborIndexPtr *arg1 = (IborIndexPtr *) 0 ;
  bool result;
  
  arg1 = (IborIndexPtr *)jarg1; 
  {
    try {
      result = (bool)IborIndexPtr_endOfMonth(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborIndex_forwardingTermStructure(void * jarg1) {
  void * jresult ;
  IborIndexPtr *arg1 = (IborIndexPtr *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (IborIndexPtr *)jarg1; 
  {
    try {
      result = IborIndexPtr_forwardingTermStructure(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborIndex_clone(void * jarg1, void * jarg2) {
  void * jresult ;
  IborIndexPtr *arg1 = (IborIndexPtr *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  SwigValueWrapper< IborIndexPtr > result;
  
  arg1 = (IborIndexPtr *)jarg1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = IborIndexPtr_clone(arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new IborIndexPtr((const IborIndexPtr &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IborIndex(void * jarg1) {
  IborIndexPtr *arg1 = (IborIndexPtr *) 0 ;
  
  arg1 = (IborIndexPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_iborindex(void * jarg1) {
  void * jresult ;
  InterestRateIndexPtr *arg1 = 0 ;
  SwigValueWrapper< IborIndexPtr > result;
  
  arg1 = (InterestRateIndexPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = as_iborindex((InterestRateIndexPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new IborIndexPtr((const IborIndexPtr &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndex__SWIG_0(char * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Integer arg2 ;
  Currency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  OvernightIndexPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Integer)jarg2; 
  arg3 = (Currency *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndexPtr *)new_OvernightIndexPtr__SWIG_0((std::string const &)*arg1,arg2,(Currency const &)*arg3,(Calendar const &)*arg4,(DayCounter const &)*arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndex__SWIG_1(char * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Integer arg2 ;
  Currency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  OvernightIndexPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Integer)jarg2; 
  arg3 = (Currency *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndexPtr *)new_OvernightIndexPtr__SWIG_0((std::string const &)*arg1,arg2,(Currency const &)*arg3,(Calendar const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OvernightIndex(void * jarg1) {
  OvernightIndexPtr *arg1 = (OvernightIndexPtr *) 0 ;
  
  arg1 = (OvernightIndexPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Libor__SWIG_0(char * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  LiborPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LiborPtr *)new_LiborPtr__SWIG_0((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(DayCounter const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Libor__SWIG_1(char * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  LiborPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LiborPtr *)new_LiborPtr__SWIG_0((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Libor(void * jarg1) {
  LiborPtr *arg1 = (LiborPtr *) 0 ;
  
  arg1 = (LiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapIndex__SWIG_0(char * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  Period *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  DayCounter *arg8 = 0 ;
  IborIndexPtr *arg9 = 0 ;
  SwapIndexPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (IborIndexPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapIndexPtr *)new_SwapIndexPtr__SWIG_0((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(Period const &)*arg6,arg7,(DayCounter const &)*arg8,(IborIndexPtr const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapIndex__SWIG_1(char * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  Period *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  DayCounter *arg8 = 0 ;
  IborIndexPtr *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  SwapIndexPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (IborIndexPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapIndexPtr *)new_SwapIndexPtr__SWIG_1((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(Period const &)*arg6,arg7,(DayCounter const &)*arg8,(IborIndexPtr const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_fixedLegTenor(void * jarg1) {
  void * jresult ;
  SwapIndexPtr *arg1 = (SwapIndexPtr *) 0 ;
  Period result;
  
  arg1 = (SwapIndexPtr *)jarg1; 
  {
    try {
      result = SwapIndexPtr_fixedLegTenor(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_SwapIndex_fixedLegConvention(void * jarg1) {
  int jresult ;
  SwapIndexPtr *arg1 = (SwapIndexPtr *) 0 ;
  BusinessDayConvention result;
  
  arg1 = (SwapIndexPtr *)jarg1; 
  {
    try {
      result = (BusinessDayConvention)SwapIndexPtr_fixedLegConvention(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_iborIndex(void * jarg1) {
  void * jresult ;
  SwapIndexPtr *arg1 = (SwapIndexPtr *) 0 ;
  SwigValueWrapper< IborIndexPtr > result;
  
  arg1 = (SwapIndexPtr *)jarg1; 
  {
    try {
      result = SwapIndexPtr_iborIndex(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new IborIndexPtr((const IborIndexPtr &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_forwardingTermStructure(void * jarg1) {
  void * jresult ;
  SwapIndexPtr *arg1 = (SwapIndexPtr *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (SwapIndexPtr *)jarg1; 
  {
    try {
      result = SwapIndexPtr_forwardingTermStructure(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwapIndex(void * jarg1) {
  SwapIndexPtr *arg1 = (SwapIndexPtr *) 0 ;
  
  arg1 = (SwapIndexPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AUDLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  AUDLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AUDLiborPtr *)new_AUDLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AUDLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  AUDLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AUDLiborPtr *)new_AUDLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AUDLibor(void * jarg1) {
  AUDLiborPtr *arg1 = (AUDLiborPtr *) 0 ;
  
  arg1 = (AUDLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CADLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  CADLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CADLiborPtr *)new_CADLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CADLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  CADLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CADLiborPtr *)new_CADLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CADLibor(void * jarg1) {
  CADLiborPtr *arg1 = (CADLiborPtr *) 0 ;
  
  arg1 = (CADLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Cdor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  CdorPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CdorPtr *)new_CdorPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Cdor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  CdorPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CdorPtr *)new_CdorPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Cdor(void * jarg1) {
  CdorPtr *arg1 = (CdorPtr *) 0 ;
  
  arg1 = (CdorPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CHFLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  CHFLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CHFLiborPtr *)new_CHFLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CHFLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  CHFLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CHFLiborPtr *)new_CHFLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CHFLibor(void * jarg1) {
  CHFLiborPtr *arg1 = (CHFLiborPtr *) 0 ;
  
  arg1 = (CHFLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DKKLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  DKKLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DKKLiborPtr *)new_DKKLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DKKLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  DKKLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DKKLiborPtr *)new_DKKLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DKKLibor(void * jarg1) {
  DKKLiborPtr *arg1 = (DKKLiborPtr *) 0 ;
  
  arg1 = (DKKLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  BbswPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BbswPtr *)new_BbswPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  BbswPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BbswPtr *)new_BbswPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw(void * jarg1) {
  BbswPtr *arg1 = (BbswPtr *) 0 ;
  
  arg1 = (BbswPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw1M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bbsw1MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw1MPtr *)new_Bbsw1MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw1M__SWIG_1() {
  void * jresult ;
  Bbsw1MPtr *result = 0 ;
  
  {
    try {
      result = (Bbsw1MPtr *)new_Bbsw1MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw1M(void * jarg1) {
  Bbsw1MPtr *arg1 = (Bbsw1MPtr *) 0 ;
  
  arg1 = (Bbsw1MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw2M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bbsw2MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw2MPtr *)new_Bbsw2MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw2M__SWIG_1() {
  void * jresult ;
  Bbsw2MPtr *result = 0 ;
  
  {
    try {
      result = (Bbsw2MPtr *)new_Bbsw2MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw2M(void * jarg1) {
  Bbsw2MPtr *arg1 = (Bbsw2MPtr *) 0 ;
  
  arg1 = (Bbsw2MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw3M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bbsw3MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw3MPtr *)new_Bbsw3MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw3M__SWIG_1() {
  void * jresult ;
  Bbsw3MPtr *result = 0 ;
  
  {
    try {
      result = (Bbsw3MPtr *)new_Bbsw3MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw3M(void * jarg1) {
  Bbsw3MPtr *arg1 = (Bbsw3MPtr *) 0 ;
  
  arg1 = (Bbsw3MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw4M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bbsw4MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw4MPtr *)new_Bbsw4MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw4M__SWIG_1() {
  void * jresult ;
  Bbsw4MPtr *result = 0 ;
  
  {
    try {
      result = (Bbsw4MPtr *)new_Bbsw4MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw4M(void * jarg1) {
  Bbsw4MPtr *arg1 = (Bbsw4MPtr *) 0 ;
  
  arg1 = (Bbsw4MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw5M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bbsw5MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw5MPtr *)new_Bbsw5MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw5M__SWIG_1() {
  void * jresult ;
  Bbsw5MPtr *result = 0 ;
  
  {
    try {
      result = (Bbsw5MPtr *)new_Bbsw5MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw5M(void * jarg1) {
  Bbsw5MPtr *arg1 = (Bbsw5MPtr *) 0 ;
  
  arg1 = (Bbsw5MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw6M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bbsw6MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw6MPtr *)new_Bbsw6MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw6M__SWIG_1() {
  void * jresult ;
  Bbsw6MPtr *result = 0 ;
  
  {
    try {
      result = (Bbsw6MPtr *)new_Bbsw6MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw6M(void * jarg1) {
  Bbsw6MPtr *arg1 = (Bbsw6MPtr *) 0 ;
  
  arg1 = (Bbsw6MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  BkbmPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BkbmPtr *)new_BkbmPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  BkbmPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BkbmPtr *)new_BkbmPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm(void * jarg1) {
  BkbmPtr *arg1 = (BkbmPtr *) 0 ;
  
  arg1 = (BkbmPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm1M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bkbm1MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm1MPtr *)new_Bkbm1MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm1M__SWIG_1() {
  void * jresult ;
  Bkbm1MPtr *result = 0 ;
  
  {
    try {
      result = (Bkbm1MPtr *)new_Bkbm1MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm1M(void * jarg1) {
  Bkbm1MPtr *arg1 = (Bkbm1MPtr *) 0 ;
  
  arg1 = (Bkbm1MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm2M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bkbm2MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm2MPtr *)new_Bkbm2MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm2M__SWIG_1() {
  void * jresult ;
  Bkbm2MPtr *result = 0 ;
  
  {
    try {
      result = (Bkbm2MPtr *)new_Bkbm2MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm2M(void * jarg1) {
  Bkbm2MPtr *arg1 = (Bkbm2MPtr *) 0 ;
  
  arg1 = (Bkbm2MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm3M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bkbm3MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm3MPtr *)new_Bkbm3MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm3M__SWIG_1() {
  void * jresult ;
  Bkbm3MPtr *result = 0 ;
  
  {
    try {
      result = (Bkbm3MPtr *)new_Bkbm3MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm3M(void * jarg1) {
  Bkbm3MPtr *arg1 = (Bkbm3MPtr *) 0 ;
  
  arg1 = (Bkbm3MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm4M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bkbm4MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm4MPtr *)new_Bkbm4MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm4M__SWIG_1() {
  void * jresult ;
  Bkbm4MPtr *result = 0 ;
  
  {
    try {
      result = (Bkbm4MPtr *)new_Bkbm4MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm4M(void * jarg1) {
  Bkbm4MPtr *arg1 = (Bkbm4MPtr *) 0 ;
  
  arg1 = (Bkbm4MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm5M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bkbm5MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm5MPtr *)new_Bkbm5MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm5M__SWIG_1() {
  void * jresult ;
  Bkbm5MPtr *result = 0 ;
  
  {
    try {
      result = (Bkbm5MPtr *)new_Bkbm5MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm5M(void * jarg1) {
  Bkbm5MPtr *arg1 = (Bkbm5MPtr *) 0 ;
  
  arg1 = (Bkbm5MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm6M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bkbm6MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm6MPtr *)new_Bkbm6MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm6M__SWIG_1() {
  void * jresult ;
  Bkbm6MPtr *result = 0 ;
  
  {
    try {
      result = (Bkbm6MPtr *)new_Bkbm6MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm6M(void * jarg1) {
  Bkbm6MPtr *arg1 = (Bkbm6MPtr *) 0 ;
  
  arg1 = (Bkbm6MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  EuriborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborPtr *)new_EuriborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EuriborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborPtr *)new_EuriborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor(void * jarg1) {
  EuriborPtr *arg1 = (EuriborPtr *) 0 ;
  
  arg1 = (EuriborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSW__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EuriborSWPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSWPtr *)new_EuriborSWPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSW__SWIG_1() {
  void * jresult ;
  EuriborSWPtr *result = 0 ;
  
  {
    try {
      result = (EuriborSWPtr *)new_EuriborSWPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuriborSW(void * jarg1) {
  EuriborSWPtr *arg1 = (EuriborSWPtr *) 0 ;
  
  arg1 = (EuriborSWPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor2W__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor2WPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor2WPtr *)new_Euribor2WPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor2W__SWIG_1() {
  void * jresult ;
  Euribor2WPtr *result = 0 ;
  
  {
    try {
      result = (Euribor2WPtr *)new_Euribor2WPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor2W(void * jarg1) {
  Euribor2WPtr *arg1 = (Euribor2WPtr *) 0 ;
  
  arg1 = (Euribor2WPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor3W__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor3WPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor3WPtr *)new_Euribor3WPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor3W__SWIG_1() {
  void * jresult ;
  Euribor3WPtr *result = 0 ;
  
  {
    try {
      result = (Euribor3WPtr *)new_Euribor3WPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor3W(void * jarg1) {
  Euribor3WPtr *arg1 = (Euribor3WPtr *) 0 ;
  
  arg1 = (Euribor3WPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor1M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor1MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor1MPtr *)new_Euribor1MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor1M__SWIG_1() {
  void * jresult ;
  Euribor1MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor1MPtr *)new_Euribor1MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor1M(void * jarg1) {
  Euribor1MPtr *arg1 = (Euribor1MPtr *) 0 ;
  
  arg1 = (Euribor1MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor2M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor2MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor2MPtr *)new_Euribor2MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor2M__SWIG_1() {
  void * jresult ;
  Euribor2MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor2MPtr *)new_Euribor2MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor2M(void * jarg1) {
  Euribor2MPtr *arg1 = (Euribor2MPtr *) 0 ;
  
  arg1 = (Euribor2MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor3M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor3MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor3MPtr *)new_Euribor3MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor3M__SWIG_1() {
  void * jresult ;
  Euribor3MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor3MPtr *)new_Euribor3MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor3M(void * jarg1) {
  Euribor3MPtr *arg1 = (Euribor3MPtr *) 0 ;
  
  arg1 = (Euribor3MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor4M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor4MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor4MPtr *)new_Euribor4MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor4M__SWIG_1() {
  void * jresult ;
  Euribor4MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor4MPtr *)new_Euribor4MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor4M(void * jarg1) {
  Euribor4MPtr *arg1 = (Euribor4MPtr *) 0 ;
  
  arg1 = (Euribor4MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor5M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor5MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor5MPtr *)new_Euribor5MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor5M__SWIG_1() {
  void * jresult ;
  Euribor5MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor5MPtr *)new_Euribor5MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor5M(void * jarg1) {
  Euribor5MPtr *arg1 = (Euribor5MPtr *) 0 ;
  
  arg1 = (Euribor5MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor6M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor6MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor6MPtr *)new_Euribor6MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor6M__SWIG_1() {
  void * jresult ;
  Euribor6MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor6MPtr *)new_Euribor6MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor6M(void * jarg1) {
  Euribor6MPtr *arg1 = (Euribor6MPtr *) 0 ;
  
  arg1 = (Euribor6MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor7M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor7MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor7MPtr *)new_Euribor7MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor7M__SWIG_1() {
  void * jresult ;
  Euribor7MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor7MPtr *)new_Euribor7MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor7M(void * jarg1) {
  Euribor7MPtr *arg1 = (Euribor7MPtr *) 0 ;
  
  arg1 = (Euribor7MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor8M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor8MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor8MPtr *)new_Euribor8MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor8M__SWIG_1() {
  void * jresult ;
  Euribor8MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor8MPtr *)new_Euribor8MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor8M(void * jarg1) {
  Euribor8MPtr *arg1 = (Euribor8MPtr *) 0 ;
  
  arg1 = (Euribor8MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor9M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor9MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor9MPtr *)new_Euribor9MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor9M__SWIG_1() {
  void * jresult ;
  Euribor9MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor9MPtr *)new_Euribor9MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor9M(void * jarg1) {
  Euribor9MPtr *arg1 = (Euribor9MPtr *) 0 ;
  
  arg1 = (Euribor9MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor10M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor10MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor10MPtr *)new_Euribor10MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor10M__SWIG_1() {
  void * jresult ;
  Euribor10MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor10MPtr *)new_Euribor10MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor10M(void * jarg1) {
  Euribor10MPtr *arg1 = (Euribor10MPtr *) 0 ;
  
  arg1 = (Euribor10MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor11M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor11MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor11MPtr *)new_Euribor11MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor11M__SWIG_1() {
  void * jresult ;
  Euribor11MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor11MPtr *)new_Euribor11MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor11M(void * jarg1) {
  Euribor11MPtr *arg1 = (Euribor11MPtr *) 0 ;
  
  arg1 = (Euribor11MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor1Y__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor1YPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor1YPtr *)new_Euribor1YPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor1Y__SWIG_1() {
  void * jresult ;
  Euribor1YPtr *result = 0 ;
  
  {
    try {
      result = (Euribor1YPtr *)new_Euribor1YPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor1Y(void * jarg1) {
  Euribor1YPtr *arg1 = (Euribor1YPtr *) 0 ;
  
  arg1 = (Euribor1YPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Euribor365Ptr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365Ptr *)new_Euribor365Ptr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Euribor365Ptr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365Ptr *)new_Euribor365Ptr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365(void * jarg1) {
  Euribor365Ptr *arg1 = (Euribor365Ptr *) 0 ;
  
  arg1 = (Euribor365Ptr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_SW__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_SWPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_SWPtr *)new_Euribor365_SWPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_SW__SWIG_1() {
  void * jresult ;
  Euribor365_SWPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_SWPtr *)new_Euribor365_SWPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_SW(void * jarg1) {
  Euribor365_SWPtr *arg1 = (Euribor365_SWPtr *) 0 ;
  
  arg1 = (Euribor365_SWPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_2W__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_2WPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_2WPtr *)new_Euribor365_2WPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_2W__SWIG_1() {
  void * jresult ;
  Euribor365_2WPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_2WPtr *)new_Euribor365_2WPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_2W(void * jarg1) {
  Euribor365_2WPtr *arg1 = (Euribor365_2WPtr *) 0 ;
  
  arg1 = (Euribor365_2WPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_3W__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_3WPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_3WPtr *)new_Euribor365_3WPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_3W__SWIG_1() {
  void * jresult ;
  Euribor365_3WPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_3WPtr *)new_Euribor365_3WPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_3W(void * jarg1) {
  Euribor365_3WPtr *arg1 = (Euribor365_3WPtr *) 0 ;
  
  arg1 = (Euribor365_3WPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_1M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_1MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_1MPtr *)new_Euribor365_1MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_1M__SWIG_1() {
  void * jresult ;
  Euribor365_1MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_1MPtr *)new_Euribor365_1MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_1M(void * jarg1) {
  Euribor365_1MPtr *arg1 = (Euribor365_1MPtr *) 0 ;
  
  arg1 = (Euribor365_1MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_2M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_2MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_2MPtr *)new_Euribor365_2MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_2M__SWIG_1() {
  void * jresult ;
  Euribor365_2MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_2MPtr *)new_Euribor365_2MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_2M(void * jarg1) {
  Euribor365_2MPtr *arg1 = (Euribor365_2MPtr *) 0 ;
  
  arg1 = (Euribor365_2MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_3M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_3MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_3MPtr *)new_Euribor365_3MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_3M__SWIG_1() {
  void * jresult ;
  Euribor365_3MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_3MPtr *)new_Euribor365_3MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_3M(void * jarg1) {
  Euribor365_3MPtr *arg1 = (Euribor365_3MPtr *) 0 ;
  
  arg1 = (Euribor365_3MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_4M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_4MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_4MPtr *)new_Euribor365_4MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_4M__SWIG_1() {
  void * jresult ;
  Euribor365_4MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_4MPtr *)new_Euribor365_4MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_4M(void * jarg1) {
  Euribor365_4MPtr *arg1 = (Euribor365_4MPtr *) 0 ;
  
  arg1 = (Euribor365_4MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_5M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_5MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_5MPtr *)new_Euribor365_5MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_5M__SWIG_1() {
  void * jresult ;
  Euribor365_5MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_5MPtr *)new_Euribor365_5MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_5M(void * jarg1) {
  Euribor365_5MPtr *arg1 = (Euribor365_5MPtr *) 0 ;
  
  arg1 = (Euribor365_5MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_6M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_6MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_6MPtr *)new_Euribor365_6MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_6M__SWIG_1() {
  void * jresult ;
  Euribor365_6MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_6MPtr *)new_Euribor365_6MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_6M(void * jarg1) {
  Euribor365_6MPtr *arg1 = (Euribor365_6MPtr *) 0 ;
  
  arg1 = (Euribor365_6MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_7M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_7MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_7MPtr *)new_Euribor365_7MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_7M__SWIG_1() {
  void * jresult ;
  Euribor365_7MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_7MPtr *)new_Euribor365_7MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_7M(void * jarg1) {
  Euribor365_7MPtr *arg1 = (Euribor365_7MPtr *) 0 ;
  
  arg1 = (Euribor365_7MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_8M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_8MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_8MPtr *)new_Euribor365_8MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_8M__SWIG_1() {
  void * jresult ;
  Euribor365_8MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_8MPtr *)new_Euribor365_8MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_8M(void * jarg1) {
  Euribor365_8MPtr *arg1 = (Euribor365_8MPtr *) 0 ;
  
  arg1 = (Euribor365_8MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_9M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_9MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_9MPtr *)new_Euribor365_9MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_9M__SWIG_1() {
  void * jresult ;
  Euribor365_9MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_9MPtr *)new_Euribor365_9MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_9M(void * jarg1) {
  Euribor365_9MPtr *arg1 = (Euribor365_9MPtr *) 0 ;
  
  arg1 = (Euribor365_9MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_10M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_10MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_10MPtr *)new_Euribor365_10MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_10M__SWIG_1() {
  void * jresult ;
  Euribor365_10MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_10MPtr *)new_Euribor365_10MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_10M(void * jarg1) {
  Euribor365_10MPtr *arg1 = (Euribor365_10MPtr *) 0 ;
  
  arg1 = (Euribor365_10MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_11M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_11MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_11MPtr *)new_Euribor365_11MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_11M__SWIG_1() {
  void * jresult ;
  Euribor365_11MPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_11MPtr *)new_Euribor365_11MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_11M(void * jarg1) {
  Euribor365_11MPtr *arg1 = (Euribor365_11MPtr *) 0 ;
  
  arg1 = (Euribor365_11MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_1Y__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Euribor365_1YPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_1YPtr *)new_Euribor365_1YPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365_1Y__SWIG_1() {
  void * jresult ;
  Euribor365_1YPtr *result = 0 ;
  
  {
    try {
      result = (Euribor365_1YPtr *)new_Euribor365_1YPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_1Y(void * jarg1) {
  Euribor365_1YPtr *arg1 = (Euribor365_1YPtr *) 0 ;
  
  arg1 = (Euribor365_1YPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  EURLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLiborPtr *)new_EURLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EURLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLiborPtr *)new_EURLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor(void * jarg1) {
  EURLiborPtr *arg1 = (EURLiborPtr *) 0 ;
  
  arg1 = (EURLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLiborSW__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLiborSWPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLiborSWPtr *)new_EURLiborSWPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLiborSW__SWIG_1() {
  void * jresult ;
  EURLiborSWPtr *result = 0 ;
  
  {
    try {
      result = (EURLiborSWPtr *)new_EURLiborSWPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLiborSW(void * jarg1) {
  EURLiborSWPtr *arg1 = (EURLiborSWPtr *) 0 ;
  
  arg1 = (EURLiborSWPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor2W__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor2WPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor2WPtr *)new_EURLibor2WPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor2W__SWIG_1() {
  void * jresult ;
  EURLibor2WPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor2WPtr *)new_EURLibor2WPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor2W(void * jarg1) {
  EURLibor2WPtr *arg1 = (EURLibor2WPtr *) 0 ;
  
  arg1 = (EURLibor2WPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor1M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor1MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor1MPtr *)new_EURLibor1MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor1M__SWIG_1() {
  void * jresult ;
  EURLibor1MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor1MPtr *)new_EURLibor1MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor1M(void * jarg1) {
  EURLibor1MPtr *arg1 = (EURLibor1MPtr *) 0 ;
  
  arg1 = (EURLibor1MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor2M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor2MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor2MPtr *)new_EURLibor2MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor2M__SWIG_1() {
  void * jresult ;
  EURLibor2MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor2MPtr *)new_EURLibor2MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor2M(void * jarg1) {
  EURLibor2MPtr *arg1 = (EURLibor2MPtr *) 0 ;
  
  arg1 = (EURLibor2MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor3M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor3MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor3MPtr *)new_EURLibor3MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor3M__SWIG_1() {
  void * jresult ;
  EURLibor3MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor3MPtr *)new_EURLibor3MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor3M(void * jarg1) {
  EURLibor3MPtr *arg1 = (EURLibor3MPtr *) 0 ;
  
  arg1 = (EURLibor3MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor4M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor4MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor4MPtr *)new_EURLibor4MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor4M__SWIG_1() {
  void * jresult ;
  EURLibor4MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor4MPtr *)new_EURLibor4MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor4M(void * jarg1) {
  EURLibor4MPtr *arg1 = (EURLibor4MPtr *) 0 ;
  
  arg1 = (EURLibor4MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor5M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor5MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor5MPtr *)new_EURLibor5MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor5M__SWIG_1() {
  void * jresult ;
  EURLibor5MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor5MPtr *)new_EURLibor5MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor5M(void * jarg1) {
  EURLibor5MPtr *arg1 = (EURLibor5MPtr *) 0 ;
  
  arg1 = (EURLibor5MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor6M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor6MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor6MPtr *)new_EURLibor6MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor6M__SWIG_1() {
  void * jresult ;
  EURLibor6MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor6MPtr *)new_EURLibor6MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor6M(void * jarg1) {
  EURLibor6MPtr *arg1 = (EURLibor6MPtr *) 0 ;
  
  arg1 = (EURLibor6MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor7M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor7MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor7MPtr *)new_EURLibor7MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor7M__SWIG_1() {
  void * jresult ;
  EURLibor7MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor7MPtr *)new_EURLibor7MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor7M(void * jarg1) {
  EURLibor7MPtr *arg1 = (EURLibor7MPtr *) 0 ;
  
  arg1 = (EURLibor7MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor8M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor8MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor8MPtr *)new_EURLibor8MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor8M__SWIG_1() {
  void * jresult ;
  EURLibor8MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor8MPtr *)new_EURLibor8MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor8M(void * jarg1) {
  EURLibor8MPtr *arg1 = (EURLibor8MPtr *) 0 ;
  
  arg1 = (EURLibor8MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor9M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor9MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor9MPtr *)new_EURLibor9MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor9M__SWIG_1() {
  void * jresult ;
  EURLibor9MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor9MPtr *)new_EURLibor9MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor9M(void * jarg1) {
  EURLibor9MPtr *arg1 = (EURLibor9MPtr *) 0 ;
  
  arg1 = (EURLibor9MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor10M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor10MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor10MPtr *)new_EURLibor10MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor10M__SWIG_1() {
  void * jresult ;
  EURLibor10MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor10MPtr *)new_EURLibor10MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor10M(void * jarg1) {
  EURLibor10MPtr *arg1 = (EURLibor10MPtr *) 0 ;
  
  arg1 = (EURLibor10MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor11M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor11MPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor11MPtr *)new_EURLibor11MPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor11M__SWIG_1() {
  void * jresult ;
  EURLibor11MPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor11MPtr *)new_EURLibor11MPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor11M(void * jarg1) {
  EURLibor11MPtr *arg1 = (EURLibor11MPtr *) 0 ;
  
  arg1 = (EURLibor11MPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor1Y__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EURLibor1YPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor1YPtr *)new_EURLibor1YPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor1Y__SWIG_1() {
  void * jresult ;
  EURLibor1YPtr *result = 0 ;
  
  {
    try {
      result = (EURLibor1YPtr *)new_EURLibor1YPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor1Y(void * jarg1) {
  EURLibor1YPtr *arg1 = (EURLibor1YPtr *) 0 ;
  
  arg1 = (EURLibor1YPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GBPLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  GBPLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GBPLiborPtr *)new_GBPLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GBPLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  GBPLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GBPLiborPtr *)new_GBPLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GBPLibor(void * jarg1) {
  GBPLiborPtr *arg1 = (GBPLiborPtr *) 0 ;
  
  arg1 = (GBPLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Jibar__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  JibarPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (JibarPtr *)new_JibarPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Jibar__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  JibarPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (JibarPtr *)new_JibarPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Jibar(void * jarg1) {
  JibarPtr *arg1 = (JibarPtr *) 0 ;
  
  arg1 = (JibarPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JPYLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  JPYLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (JPYLiborPtr *)new_JPYLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JPYLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  JPYLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (JPYLiborPtr *)new_JPYLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JPYLibor(void * jarg1) {
  JPYLiborPtr *arg1 = (JPYLiborPtr *) 0 ;
  
  arg1 = (JPYLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NZDLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  NZDLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (NZDLiborPtr *)new_NZDLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NZDLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  NZDLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (NZDLiborPtr *)new_NZDLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NZDLibor(void * jarg1) {
  NZDLiborPtr *arg1 = (NZDLiborPtr *) 0 ;
  
  arg1 = (NZDLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SEKLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  SEKLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SEKLiborPtr *)new_SEKLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SEKLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  SEKLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SEKLiborPtr *)new_SEKLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SEKLibor(void * jarg1) {
  SEKLiborPtr *arg1 = (SEKLiborPtr *) 0 ;
  
  arg1 = (SEKLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Tibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  TiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TiborPtr *)new_TiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Tibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  TiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TiborPtr *)new_TiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Tibor(void * jarg1) {
  TiborPtr *arg1 = (TiborPtr *) 0 ;
  
  arg1 = (TiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TRLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  TRLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TRLiborPtr *)new_TRLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TRLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  TRLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TRLiborPtr *)new_TRLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TRLibor(void * jarg1) {
  TRLiborPtr *arg1 = (TRLiborPtr *) 0 ;
  
  arg1 = (TRLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USDLibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  USDLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (USDLiborPtr *)new_USDLiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USDLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  USDLiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (USDLiborPtr *)new_USDLiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_USDLibor(void * jarg1) {
  USDLiborPtr *arg1 = (USDLiborPtr *) 0 ;
  
  arg1 = (USDLiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Zibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ZiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZiborPtr *)new_ZiborPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Zibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  ZiborPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZiborPtr *)new_ZiborPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Zibor(void * jarg1) {
  ZiborPtr *arg1 = (ZiborPtr *) 0 ;
  
  arg1 = (ZiborPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Aonia__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  AoniaPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AoniaPtr *)new_AoniaPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Aonia__SWIG_1() {
  void * jresult ;
  AoniaPtr *result = 0 ;
  
  {
    try {
      result = (AoniaPtr *)new_AoniaPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Aonia(void * jarg1) {
  AoniaPtr *arg1 = (AoniaPtr *) 0 ;
  
  arg1 = (AoniaPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Eonia__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  EoniaPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EoniaPtr *)new_EoniaPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Eonia__SWIG_1() {
  void * jresult ;
  EoniaPtr *result = 0 ;
  
  {
    try {
      result = (EoniaPtr *)new_EoniaPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Eonia(void * jarg1) {
  EoniaPtr *arg1 = (EoniaPtr *) 0 ;
  
  arg1 = (EoniaPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Sonia__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  SoniaPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SoniaPtr *)new_SoniaPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Sonia__SWIG_1() {
  void * jresult ;
  SoniaPtr *result = 0 ;
  
  {
    try {
      result = (SoniaPtr *)new_SoniaPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Sonia(void * jarg1) {
  SoniaPtr *arg1 = (SoniaPtr *) 0 ;
  
  arg1 = (SoniaPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FedFunds__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  FedFundsPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FedFundsPtr *)new_FedFundsPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FedFunds__SWIG_1() {
  void * jresult ;
  FedFundsPtr *result = 0 ;
  
  {
    try {
      result = (FedFundsPtr *)new_FedFundsPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FedFunds(void * jarg1) {
  FedFundsPtr *arg1 = (FedFundsPtr *) 0 ;
  
  arg1 = (FedFundsPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Nzocr__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  NzocrPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (NzocrPtr *)new_NzocrPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Nzocr__SWIG_1() {
  void * jresult ;
  NzocrPtr *result = 0 ;
  
  {
    try {
      result = (NzocrPtr *)new_NzocrPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Nzocr(void * jarg1) {
  NzocrPtr *arg1 = (NzocrPtr *) 0 ;
  
  arg1 = (NzocrPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIsdaFixA__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  EuriborSwapIsdaFixAPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixAPtr *)new_EuriborSwapIsdaFixAPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIsdaFixA__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EuriborSwapIsdaFixAPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixAPtr *)new_EuriborSwapIsdaFixAPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIsdaFixA__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  EuriborSwapIsdaFixAPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixAPtr *)new_EuriborSwapIsdaFixAPtr__SWIG_2((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuriborSwapIsdaFixA(void * jarg1) {
  EuriborSwapIsdaFixAPtr *arg1 = (EuriborSwapIsdaFixAPtr *) 0 ;
  
  arg1 = (EuriborSwapIsdaFixAPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIsdaFixB__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  EuriborSwapIsdaFixBPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixBPtr *)new_EuriborSwapIsdaFixBPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIsdaFixB__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EuriborSwapIsdaFixBPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixBPtr *)new_EuriborSwapIsdaFixBPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIsdaFixB__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  EuriborSwapIsdaFixBPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixBPtr *)new_EuriborSwapIsdaFixBPtr__SWIG_2((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuriborSwapIsdaFixB(void * jarg1) {
  EuriborSwapIsdaFixBPtr *arg1 = (EuriborSwapIsdaFixBPtr *) 0 ;
  
  arg1 = (EuriborSwapIsdaFixBPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIfrFix__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  EuriborSwapIfrFixPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIfrFixPtr *)new_EuriborSwapIfrFixPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIfrFix__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EuriborSwapIfrFixPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIfrFixPtr *)new_EuriborSwapIfrFixPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIfrFix__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  EuriborSwapIfrFixPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIfrFixPtr *)new_EuriborSwapIfrFixPtr__SWIG_2((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuriborSwapIfrFix(void * jarg1) {
  EuriborSwapIfrFixPtr *arg1 = (EuriborSwapIfrFixPtr *) 0 ;
  
  arg1 = (EuriborSwapIfrFixPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIsdaFixA__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  EurLiborSwapIsdaFixAPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixAPtr *)new_EurLiborSwapIsdaFixAPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIsdaFixA__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EurLiborSwapIsdaFixAPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixAPtr *)new_EurLiborSwapIsdaFixAPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIsdaFixA__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  EurLiborSwapIsdaFixAPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixAPtr *)new_EurLiborSwapIsdaFixAPtr__SWIG_2((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EurLiborSwapIsdaFixA(void * jarg1) {
  EurLiborSwapIsdaFixAPtr *arg1 = (EurLiborSwapIsdaFixAPtr *) 0 ;
  
  arg1 = (EurLiborSwapIsdaFixAPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIsdaFixB__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  EurLiborSwapIsdaFixBPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixBPtr *)new_EurLiborSwapIsdaFixBPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIsdaFixB__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EurLiborSwapIsdaFixBPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixBPtr *)new_EurLiborSwapIsdaFixBPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIsdaFixB__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  EurLiborSwapIsdaFixBPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixBPtr *)new_EurLiborSwapIsdaFixBPtr__SWIG_2((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EurLiborSwapIsdaFixB(void * jarg1) {
  EurLiborSwapIsdaFixBPtr *arg1 = (EurLiborSwapIsdaFixBPtr *) 0 ;
  
  arg1 = (EurLiborSwapIsdaFixBPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIfrFix__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  EurLiborSwapIfrFixPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIfrFixPtr *)new_EurLiborSwapIfrFixPtr__SWIG_0((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIfrFix__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EurLiborSwapIfrFixPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIfrFixPtr *)new_EurLiborSwapIfrFixPtr__SWIG_0((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIfrFix__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  EurLiborSwapIfrFixPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIfrFixPtr *)new_EurLiborSwapIfrFixPtr__SWIG_2((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EurLiborSwapIfrFix(void * jarg1) {
  EurLiborSwapIfrFixPtr *arg1 = (EurLiborSwapIfrFixPtr *) 0 ;
  
  arg1 = (EurLiborSwapIfrFixPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Brent_setMaxEvaluations(void * jarg1, unsigned long jarg2) {
  Brent *arg1 = (Brent *) 0 ;
  Size arg2 ;
  
  arg1 = (Brent *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Brent_setLowerBound(void * jarg1, double jarg2) {
  Brent *arg1 = (Brent *) 0 ;
  Real arg2 ;
  
  arg1 = (Brent *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Brent_setUpperBound(void * jarg1, double jarg2) {
  Brent *arg1 = (Brent *) 0 ;
  Real arg2 ;
  
  arg1 = (Brent *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Brent_solve__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Brent *arg1 = (Brent *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Brent *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)Brent_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Brent_solve__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  Brent *arg1 = (Brent *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (Brent *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)Brent_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Brent() {
  void * jresult ;
  Brent *result = 0 ;
  
  {
    try {
      result = (Brent *)new Brent();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Brent(void * jarg1) {
  Brent *arg1 = (Brent *) 0 ;
  
  arg1 = (Brent *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Bisection_setMaxEvaluations(void * jarg1, unsigned long jarg2) {
  Bisection *arg1 = (Bisection *) 0 ;
  Size arg2 ;
  
  arg1 = (Bisection *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Bisection_setLowerBound(void * jarg1, double jarg2) {
  Bisection *arg1 = (Bisection *) 0 ;
  Real arg2 ;
  
  arg1 = (Bisection *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Bisection_setUpperBound(void * jarg1, double jarg2) {
  Bisection *arg1 = (Bisection *) 0 ;
  Real arg2 ;
  
  arg1 = (Bisection *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bisection_solve__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Bisection *arg1 = (Bisection *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Bisection *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)Bisection_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bisection_solve__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  Bisection *arg1 = (Bisection *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (Bisection *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)Bisection_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bisection() {
  void * jresult ;
  Bisection *result = 0 ;
  
  {
    try {
      result = (Bisection *)new Bisection();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bisection(void * jarg1) {
  Bisection *arg1 = (Bisection *) 0 ;
  
  arg1 = (Bisection *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FalsePosition_setMaxEvaluations(void * jarg1, unsigned long jarg2) {
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  Size arg2 ;
  
  arg1 = (FalsePosition *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FalsePosition_setLowerBound(void * jarg1, double jarg2) {
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  Real arg2 ;
  
  arg1 = (FalsePosition *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FalsePosition_setUpperBound(void * jarg1, double jarg2) {
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  Real arg2 ;
  
  arg1 = (FalsePosition *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FalsePosition_solve__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (FalsePosition *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)FalsePosition_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FalsePosition_solve__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (FalsePosition *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)FalsePosition_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FalsePosition() {
  void * jresult ;
  FalsePosition *result = 0 ;
  
  {
    try {
      result = (FalsePosition *)new FalsePosition();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FalsePosition(void * jarg1) {
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  
  arg1 = (FalsePosition *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Ridder_setMaxEvaluations(void * jarg1, unsigned long jarg2) {
  Ridder *arg1 = (Ridder *) 0 ;
  Size arg2 ;
  
  arg1 = (Ridder *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Ridder_setLowerBound(void * jarg1, double jarg2) {
  Ridder *arg1 = (Ridder *) 0 ;
  Real arg2 ;
  
  arg1 = (Ridder *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Ridder_setUpperBound(void * jarg1, double jarg2) {
  Ridder *arg1 = (Ridder *) 0 ;
  Real arg2 ;
  
  arg1 = (Ridder *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Ridder_solve__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Ridder *arg1 = (Ridder *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Ridder *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)Ridder_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Ridder_solve__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  Ridder *arg1 = (Ridder *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (Ridder *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)Ridder_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Ridder() {
  void * jresult ;
  Ridder *result = 0 ;
  
  {
    try {
      result = (Ridder *)new Ridder();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Ridder(void * jarg1) {
  Ridder *arg1 = (Ridder *) 0 ;
  
  arg1 = (Ridder *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Secant_setMaxEvaluations(void * jarg1, unsigned long jarg2) {
  Secant *arg1 = (Secant *) 0 ;
  Size arg2 ;
  
  arg1 = (Secant *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Secant_setLowerBound(void * jarg1, double jarg2) {
  Secant *arg1 = (Secant *) 0 ;
  Real arg2 ;
  
  arg1 = (Secant *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Secant_setUpperBound(void * jarg1, double jarg2) {
  Secant *arg1 = (Secant *) 0 ;
  Real arg2 ;
  
  arg1 = (Secant *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Secant_solve__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Secant *arg1 = (Secant *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Secant *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)Secant_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Secant_solve__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  Secant *arg1 = (Secant *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (Secant *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)Secant_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Secant() {
  void * jresult ;
  Secant *result = 0 ;
  
  {
    try {
      result = (Secant *)new Secant();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Secant(void * jarg1) {
  Secant *arg1 = (Secant *) 0 ;
  
  arg1 = (Secant *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Constraint(void * jarg1) {
  Constraint *arg1 = (Constraint *) 0 ;
  
  arg1 = (Constraint *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BoundaryConstraint(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  BoundaryConstraint *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (BoundaryConstraint *)new BoundaryConstraint(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BoundaryConstraint(void * jarg1) {
  BoundaryConstraint *arg1 = (BoundaryConstraint *) 0 ;
  
  arg1 = (BoundaryConstraint *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoConstraint() {
  void * jresult ;
  NoConstraint *result = 0 ;
  
  {
    try {
      result = (NoConstraint *)new NoConstraint();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NoConstraint(void * jarg1) {
  NoConstraint *arg1 = (NoConstraint *) 0 ;
  
  arg1 = (NoConstraint *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PositiveConstraint() {
  void * jresult ;
  PositiveConstraint *result = 0 ;
  
  {
    try {
      result = (PositiveConstraint *)new PositiveConstraint();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PositiveConstraint(void * jarg1) {
  PositiveConstraint *arg1 = (PositiveConstraint *) 0 ;
  
  arg1 = (PositiveConstraint *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CompositeConstraint(void * jarg1, void * jarg2) {
  void * jresult ;
  Constraint *arg1 = 0 ;
  Constraint *arg2 = 0 ;
  CompositeConstraint *result = 0 ;
  
  arg1 = (Constraint *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return 0;
  } 
  arg2 = (Constraint *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CompositeConstraint *)new CompositeConstraint((Constraint const &)*arg1,(Constraint const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CompositeConstraint(void * jarg1) {
  CompositeConstraint *arg1 = (CompositeConstraint *) 0 ;
  
  arg1 = (CompositeConstraint *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonhomogeneousBoundaryConstraint(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  NonhomogeneousBoundaryConstraint *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (NonhomogeneousBoundaryConstraint *)new NonhomogeneousBoundaryConstraint((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NonhomogeneousBoundaryConstraint(void * jarg1) {
  NonhomogeneousBoundaryConstraint *arg1 = (NonhomogeneousBoundaryConstraint *) 0 ;
  
  arg1 = (NonhomogeneousBoundaryConstraint *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EndCriteria(unsigned long jarg1, unsigned long jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  EndCriteria *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (EndCriteria *)new EndCriteria(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_EndCriteria_call(void * jarg1, unsigned long jarg2, void * jarg3, unsigned int jarg4, double jarg5, double jarg6, double jarg7, double jarg8, void * jarg9) {
  unsigned int jresult ;
  EndCriteria *arg1 = (EndCriteria *) 0 ;
  Size arg2 ;
  Size *arg3 = 0 ;
  bool arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  EndCriteria::Type *arg9 = 0 ;
  bool result;
  
  arg1 = (EndCriteria *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Size & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (EndCriteria::Type *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria::Type & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)((EndCriteria const *)arg1)->operator ()(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EndCriteria(void * jarg1) {
  EndCriteria *arg1 = (EndCriteria *) 0 ;
  
  arg1 = (EndCriteria *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OptimizationMethod(void * jarg1) {
  OptimizationMethod *arg1 = (OptimizationMethod *) 0 ;
  
  arg1 = (OptimizationMethod *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConjugateGradient() {
  void * jresult ;
  ConjugateGradient *result = 0 ;
  
  {
    try {
      result = (ConjugateGradient *)new ConjugateGradient();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConjugateGradient(void * jarg1) {
  ConjugateGradient *arg1 = (ConjugateGradient *) 0 ;
  
  arg1 = (ConjugateGradient *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Simplex(double jarg1) {
  void * jresult ;
  Real arg1 ;
  Simplex *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (Simplex *)new Simplex(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Simplex(void * jarg1) {
  Simplex *arg1 = (Simplex *) 0 ;
  
  arg1 = (Simplex *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SteepestDescent() {
  void * jresult ;
  SteepestDescent *result = 0 ;
  
  {
    try {
      result = (SteepestDescent *)new SteepestDescent();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SteepestDescent(void * jarg1) {
  SteepestDescent *arg1 = (SteepestDescent *) 0 ;
  
  arg1 = (SteepestDescent *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BFGS() {
  void * jresult ;
  BFGS *result = 0 ;
  
  {
    try {
      result = (BFGS *)new BFGS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BFGS(void * jarg1) {
  BFGS *arg1 = (BFGS *) 0 ;
  
  arg1 = (BFGS *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LevenbergMarquardt__SWIG_0(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  LevenbergMarquardt *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LevenbergMarquardt__SWIG_1(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  LevenbergMarquardt *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LevenbergMarquardt__SWIG_2(double jarg1) {
  void * jresult ;
  Real arg1 ;
  LevenbergMarquardt *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LevenbergMarquardt__SWIG_3() {
  void * jresult ;
  LevenbergMarquardt *result = 0 ;
  
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LevenbergMarquardt(void * jarg1) {
  LevenbergMarquardt *arg1 = (LevenbergMarquardt *) 0 ;
  
  arg1 = (LevenbergMarquardt *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DifferentialEvolution() {
  void * jresult ;
  DifferentialEvolution *result = 0 ;
  
  {
    try {
      result = (DifferentialEvolution *)new DifferentialEvolution();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DifferentialEvolution(void * jarg1) {
  DifferentialEvolution *arg1 = (DifferentialEvolution *) 0 ;
  
  arg1 = (DifferentialEvolution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SamplerGaussian__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  unsigned long arg1 ;
  SamplerGaussian *result = 0 ;
  
  arg1 = (unsigned long)jarg1; 
  {
    try {
      result = (SamplerGaussian *)new SamplerGaussian(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SamplerGaussian__SWIG_1() {
  void * jresult ;
  SamplerGaussian *result = 0 ;
  
  {
    try {
      result = (SamplerGaussian *)new SamplerGaussian();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SamplerGaussian(void * jarg1) {
  SamplerGaussian *arg1 = (SamplerGaussian *) 0 ;
  
  arg1 = (SamplerGaussian *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SamplerLogNormal__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  unsigned long arg1 ;
  SamplerLogNormal *result = 0 ;
  
  arg1 = (unsigned long)jarg1; 
  {
    try {
      result = (SamplerLogNormal *)new SamplerLogNormal(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SamplerLogNormal__SWIG_1() {
  void * jresult ;
  SamplerLogNormal *result = 0 ;
  
  {
    try {
      result = (SamplerLogNormal *)new SamplerLogNormal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SamplerLogNormal(void * jarg1) {
  SamplerLogNormal *arg1 = (SamplerLogNormal *) 0 ;
  
  arg1 = (SamplerLogNormal *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SamplerMirrorGaussian__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  unsigned long arg3 ;
  SamplerMirrorGaussian *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (unsigned long)jarg3; 
  {
    try {
      result = (SamplerMirrorGaussian *)new SamplerMirrorGaussian((Array const &)*arg1,(Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SamplerMirrorGaussian__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SamplerMirrorGaussian *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SamplerMirrorGaussian *)new SamplerMirrorGaussian((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SamplerMirrorGaussian(void * jarg1) {
  SamplerMirrorGaussian *arg1 = (SamplerMirrorGaussian *) 0 ;
  
  arg1 = (SamplerMirrorGaussian *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ProbabilityBoltzmannDownhill__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  unsigned long arg1 ;
  ProbabilityBoltzmannDownhill *result = 0 ;
  
  arg1 = (unsigned long)jarg1; 
  {
    try {
      result = (ProbabilityBoltzmannDownhill *)new ProbabilityBoltzmannDownhill(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ProbabilityBoltzmannDownhill__SWIG_1() {
  void * jresult ;
  ProbabilityBoltzmannDownhill *result = 0 ;
  
  {
    try {
      result = (ProbabilityBoltzmannDownhill *)new ProbabilityBoltzmannDownhill();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ProbabilityBoltzmannDownhill(void * jarg1) {
  ProbabilityBoltzmannDownhill *arg1 = (ProbabilityBoltzmannDownhill *) 0 ;
  
  arg1 = (ProbabilityBoltzmannDownhill *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TemperatureExponential__SWIG_0(double jarg1, unsigned long jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  Real arg3 ;
  TemperatureExponential *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (TemperatureExponential *)new TemperatureExponential(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TemperatureExponential__SWIG_1(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  TemperatureExponential *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TemperatureExponential *)new TemperatureExponential(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TemperatureExponential(void * jarg1) {
  TemperatureExponential *arg1 = (TemperatureExponential *) 0 ;
  
  arg1 = (TemperatureExponential *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ReannealingTrivial() {
  void * jresult ;
  ReannealingTrivial *result = 0 ;
  
  {
    try {
      result = (ReannealingTrivial *)new ReannealingTrivial();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ReannealingTrivial(void * jarg1) {
  ReannealingTrivial *arg1 = (ReannealingTrivial *) 0 ;
  
  arg1 = (ReannealingTrivial *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianSimulatedAnnealing__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7, int jarg8, unsigned long jarg9) {
  void * jresult ;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  GaussianSimulatedAnnealing::ResetScheme arg8 ;
  Size arg9 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (GaussianSimulatedAnnealing::ResetScheme)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianSimulatedAnnealing__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7, int jarg8) {
  void * jresult ;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  GaussianSimulatedAnnealing::ResetScheme arg8 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (GaussianSimulatedAnnealing::ResetScheme)jarg8; 
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianSimulatedAnnealing__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7) {
  void * jresult ;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianSimulatedAnnealing__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6) {
  void * jresult ;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianSimulatedAnnealing__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianSimulatedAnnealing__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianSimulatedAnnealing__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianSimulatedAnnealing(void * jarg1) {
  GaussianSimulatedAnnealing *arg1 = (GaussianSimulatedAnnealing *) 0 ;
  
  arg1 = (GaussianSimulatedAnnealing *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MirrorGaussianSimulatedAnnealing__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7, int jarg8, unsigned long jarg9) {
  void * jresult ;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  MirrorGaussianSimulatedAnnealing::ResetScheme arg8 ;
  Size arg9 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerMirrorGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerMirrorGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (MirrorGaussianSimulatedAnnealing::ResetScheme)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MirrorGaussianSimulatedAnnealing__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7, int jarg8) {
  void * jresult ;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  MirrorGaussianSimulatedAnnealing::ResetScheme arg8 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerMirrorGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerMirrorGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (MirrorGaussianSimulatedAnnealing::ResetScheme)jarg8; 
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MirrorGaussianSimulatedAnnealing__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7) {
  void * jresult ;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerMirrorGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerMirrorGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MirrorGaussianSimulatedAnnealing__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6) {
  void * jresult ;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerMirrorGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerMirrorGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MirrorGaussianSimulatedAnnealing__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerMirrorGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerMirrorGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MirrorGaussianSimulatedAnnealing__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerMirrorGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerMirrorGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MirrorGaussianSimulatedAnnealing__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerMirrorGaussian *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerMirrorGaussian const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MirrorGaussianSimulatedAnnealing(void * jarg1) {
  MirrorGaussianSimulatedAnnealing *arg1 = (MirrorGaussianSimulatedAnnealing *) 0 ;
  
  arg1 = (MirrorGaussianSimulatedAnnealing *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalSimulatedAnnealing__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7, int jarg8, unsigned long jarg9) {
  void * jresult ;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  LogNormalSimulatedAnnealing::ResetScheme arg8 ;
  Size arg9 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerLogNormal *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerLogNormal const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (LogNormalSimulatedAnnealing::ResetScheme)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalSimulatedAnnealing__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7, int jarg8) {
  void * jresult ;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  LogNormalSimulatedAnnealing::ResetScheme arg8 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerLogNormal *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerLogNormal const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (LogNormalSimulatedAnnealing::ResetScheme)jarg8; 
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalSimulatedAnnealing__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7) {
  void * jresult ;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerLogNormal *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerLogNormal const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalSimulatedAnnealing__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6) {
  void * jresult ;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerLogNormal *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerLogNormal const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalSimulatedAnnealing__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerLogNormal *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerLogNormal const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalSimulatedAnnealing__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerLogNormal *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerLogNormal const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalSimulatedAnnealing__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  arg1 = (SamplerLogNormal *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SamplerLogNormal const & type is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & type is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogNormalSimulatedAnnealing(void * jarg1) {
  LogNormalSimulatedAnnealing *arg1 = (LogNormalSimulatedAnnealing *) 0 ;
  
  arg1 = (LogNormalSimulatedAnnealing *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Optimizer_solve(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Optimizer *arg1 = (Optimizer *) 0 ;
  CostFunctionDelegate *arg2 = (CostFunctionDelegate *) 0 ;
  Constraint *arg3 = 0 ;
  OptimizationMethod *arg4 = 0 ;
  EndCriteria *arg5 = 0 ;
  Array *arg6 = 0 ;
  Array result;
  
  arg1 = (Optimizer *)jarg1; 
  arg2 = (CostFunctionDelegate *)jarg2; 
  arg3 = (Constraint *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint & type is null", 0);
    return 0;
  } 
  arg4 = (OptimizationMethod *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return 0;
  } 
  arg5 = (EndCriteria *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria & type is null", 0);
    return 0;
  } 
  arg6 = (Array *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & type is null", 0);
    return 0;
  } 
  {
    try {
      result = Optimizer_solve(arg1,arg2,*arg3,*arg4,*arg5,*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Optimizer() {
  void * jresult ;
  Optimizer *result = 0 ;
  
  {
    try {
      result = (Optimizer *)new Optimizer();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Optimizer(void * jarg1) {
  Optimizer *arg1 = (Optimizer *) 0 ;
  
  arg1 = (Optimizer *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  BlackVolTermStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (BlackVolTermStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_BlackVolTermStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_BlackVolTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVolTermStructure() {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< BlackVolTermStructure > *)new boost::shared_ptr< BlackVolTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackVolTermStructure(void * jarg1) {
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_referenceDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_maxDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_maxTime(void * jarg1) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_minStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_maxStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackVol__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->blackVol((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackVol__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->blackVol((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackVol__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->blackVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackVol__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->blackVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackVariance__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackVariance__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackVariance__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackVariance__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackForwardVol__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackForwardVol__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackForwardVol__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackForwardVol__SWIG_3(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackForwardVariance__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackForwardVariance__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackForwardVariance__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_blackForwardVariance__SWIG_3(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = (boost::shared_ptr< BlackVolTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVolTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = 0 ;
  Handle< BlackVolTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< BlackVolTermStructure > *)new Handle< BlackVolTermStructure >((boost::shared_ptr< BlackVolTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVolTermStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< BlackVolTermStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< BlackVolTermStructure > *)new Handle< BlackVolTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  boost::shared_ptr< BlackVolTermStructure > result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< BlackVolTermStructure >((const boost::shared_ptr< BlackVolTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_BlackVolTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackVolTermStructureHandle(void * jarg1) {
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_minStrike(void * jarg1) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_maxStrike(void * jarg1) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackVol__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->blackVol((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackVol__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->blackVol((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackVol__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->blackVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackVol__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->blackVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackVariance__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackVariance__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackVariance__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackVariance__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackForwardVol__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackForwardVol__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Volatility result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackForwardVol__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackForwardVol__SWIG_3(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Volatility result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackForwardVariance__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackForwardVariance__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackForwardVariance__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_blackForwardVariance__SWIG_3(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableBlackVolTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< BlackVolTermStructure > *arg1 = 0 ;
  RelinkableHandle< BlackVolTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< BlackVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< BlackVolTermStructure > *)new RelinkableHandle< BlackVolTermStructure >((boost::shared_ptr< BlackVolTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableBlackVolTermStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< BlackVolTermStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< BlackVolTermStructure > *)new RelinkableHandle< BlackVolTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableBlackVolTermStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< BlackVolTermStructure > *arg1 = (RelinkableHandle< BlackVolTermStructure > *) 0 ;
  boost::shared_ptr< BlackVolTermStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< BlackVolTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< BlackVolTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< BlackVolTermStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< BlackVolTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableBlackVolTermStructureHandle(void * jarg1) {
  RelinkableHandle< BlackVolTermStructure > *arg1 = (RelinkableHandle< BlackVolTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  LocalVolTermStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (LocalVolTermStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_LocalVolTermStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_LocalVolTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolTermStructure() {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< LocalVolTermStructure > *)new boost::shared_ptr< LocalVolTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LocalVolTermStructure(void * jarg1) {
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_referenceDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_maxDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_maxTime(void * jarg1) {
  double jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Time result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_minStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_maxStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_localVol__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->localVol((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_localVol__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->localVol((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_localVol__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->localVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_localVol__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->localVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = (boost::shared_ptr< LocalVolTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  Handle< LocalVolTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< LocalVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< LocalVolTermStructure > *)new Handle< LocalVolTermStructure >((boost::shared_ptr< LocalVolTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolTermStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< LocalVolTermStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< LocalVolTermStructure > *)new Handle< LocalVolTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  boost::shared_ptr< LocalVolTermStructure > result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< LocalVolTermStructure >((const boost::shared_ptr< LocalVolTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_LocalVolTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LocalVolTermStructureHandle(void * jarg1) {
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_minStrike(void * jarg1) {
  double jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_maxStrike(void * jarg1) {
  double jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_localVol__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->localVol((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_localVol__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->localVol((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_localVol__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->localVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_localVol__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->localVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableLocalVolTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  RelinkableHandle< LocalVolTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< LocalVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< LocalVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< LocalVolTermStructure > *)new RelinkableHandle< LocalVolTermStructure >((boost::shared_ptr< LocalVolTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableLocalVolTermStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< LocalVolTermStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< LocalVolTermStructure > *)new RelinkableHandle< LocalVolTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableLocalVolTermStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< LocalVolTermStructure > *arg1 = (RelinkableHandle< LocalVolTermStructure > *) 0 ;
  boost::shared_ptr< LocalVolTermStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< LocalVolTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< LocalVolTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< LocalVolTermStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< LocalVolTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableLocalVolTermStructureHandle(void * jarg1) {
  RelinkableHandle< LocalVolTermStructure > *arg1 = (RelinkableHandle< LocalVolTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  OptionletVolatilityStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (OptionletVolatilityStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_OptionletVolatilityStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_OptionletVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletVolatilityStructure() {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< OptionletVolatilityStructure > *)new boost::shared_ptr< OptionletVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OptionletVolatilityStructure(void * jarg1) {
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_referenceDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_maxDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_maxTime(void * jarg1) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Time result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_minStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_maxStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_volatility__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_volatility__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_volatility__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_volatility__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_blackVariance__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_blackVariance__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_blackVariance__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_blackVariance__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = 0 ;
  Handle< OptionletVolatilityStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< OptionletVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< OptionletVolatilityStructure > *)new Handle< OptionletVolatilityStructure >((boost::shared_ptr< OptionletVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletVolatilityStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< OptionletVolatilityStructure > *)new Handle< OptionletVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  boost::shared_ptr< OptionletVolatilityStructure > result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< OptionletVolatilityStructure >((const boost::shared_ptr< OptionletVolatilityStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_OptionletVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OptionletVolatilityStructureHandle(void * jarg1) {
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_minStrike(void * jarg1) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_maxStrike(void * jarg1) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_volatility__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_volatility__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_volatility__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_volatility__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_blackVariance__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_blackVariance__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Real result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_blackVariance__SWIG_2(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_blackVariance__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  Real result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableOptionletVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg1 = 0 ;
  RelinkableHandle< OptionletVolatilityStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< OptionletVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< OptionletVolatilityStructure > *)new RelinkableHandle< OptionletVolatilityStructure >((boost::shared_ptr< OptionletVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableOptionletVolatilityStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< OptionletVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< OptionletVolatilityStructure > *)new RelinkableHandle< OptionletVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableOptionletVolatilityStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< OptionletVolatilityStructure > *arg1 = (RelinkableHandle< OptionletVolatilityStructure > *) 0 ;
  boost::shared_ptr< OptionletVolatilityStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< OptionletVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< OptionletVolatilityStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< OptionletVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableOptionletVolatilityStructureHandle(void * jarg1) {
  RelinkableHandle< OptionletVolatilityStructure > *arg1 = (RelinkableHandle< OptionletVolatilityStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  SwaptionVolatilityStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (SwaptionVolatilityStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_SwaptionVolatilityStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_SwaptionVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityStructure() {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< SwaptionVolatilityStructure > *)new boost::shared_ptr< SwaptionVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionVolatilityStructure(void * jarg1) {
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_referenceDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_maxSwapTenor(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Period result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxSwapTenor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_maxSwapLength(void * jarg1) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Time result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxSwapLength();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_minStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_maxStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_volatility__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_volatility__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_volatility__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_volatility__SWIG_3(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_blackVariance__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  Real result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_blackVariance__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_blackVariance__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  Real result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_blackVariance__SWIG_3(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_optionDateFromTenor(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (*arg1)->optionDateFromTenor((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = 0 ;
  Handle< SwaptionVolatilityStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< SwaptionVolatilityStructure > *)new Handle< SwaptionVolatilityStructure >((boost::shared_ptr< SwaptionVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< SwaptionVolatilityStructure > *)new Handle< SwaptionVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  boost::shared_ptr< SwaptionVolatilityStructure > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< SwaptionVolatilityStructure >((const boost::shared_ptr< SwaptionVolatilityStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_SwaptionVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionVolatilityStructureHandle(void * jarg1) {
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_maxSwapTenor(void * jarg1) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxSwapTenor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_maxSwapLength(void * jarg1) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxSwapLength();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_minStrike(void * jarg1) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_maxStrike(void * jarg1) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_volatility__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_volatility__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  Volatility result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_volatility__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_volatility__SWIG_3(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  Volatility result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_blackVariance__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_blackVariance__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_blackVariance__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_blackVariance__SWIG_3(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_optionDateFromTenor(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Date result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (*arg1)->optionDateFromTenor((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableSwaptionVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg1 = 0 ;
  RelinkableHandle< SwaptionVolatilityStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< SwaptionVolatilityStructure > *)new RelinkableHandle< SwaptionVolatilityStructure >((boost::shared_ptr< SwaptionVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableSwaptionVolatilityStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< SwaptionVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< SwaptionVolatilityStructure > *)new RelinkableHandle< SwaptionVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableSwaptionVolatilityStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< SwaptionVolatilityStructure > *arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *) 0 ;
  boost::shared_ptr< SwaptionVolatilityStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< SwaptionVolatilityStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< SwaptionVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableSwaptionVolatilityStructureHandle(void * jarg1) {
  RelinkableHandle< SwaptionVolatilityStructure > *arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackConstantVol__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Volatility arg3 ;
  DayCounter *arg4 = 0 ;
  BlackConstantVolPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Volatility)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackConstantVolPtr *)new_BlackConstantVolPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackConstantVol__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BlackConstantVolPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackConstantVolPtr *)new_BlackConstantVolPtr__SWIG_1((Date const &)*arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackConstantVol__SWIG_2(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Volatility arg3 ;
  DayCounter *arg4 = 0 ;
  BlackConstantVolPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Volatility)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackConstantVolPtr *)new_BlackConstantVolPtr__SWIG_2(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackConstantVol__SWIG_3(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BlackConstantVolPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackConstantVolPtr *)new_BlackConstantVolPtr__SWIG_3(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackConstantVol(void * jarg1) {
  BlackConstantVolPtr *arg1 = (BlackConstantVolPtr *) 0 ;
  
  arg1 = (BlackConstantVolPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVarianceCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  bool arg5 ;
  BlackVarianceCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (BlackVarianceCurvePtr *)new_BlackVarianceCurvePtr__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< double > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVarianceCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BlackVarianceCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackVarianceCurvePtr *)new_BlackVarianceCurvePtr__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< double > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackVarianceCurve(void * jarg1) {
  BlackVarianceCurvePtr *arg1 = (BlackVarianceCurvePtr *) 0 ;
  
  arg1 = (BlackVarianceCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__BlackVarianceSurface(void * jarg1) {
  BlackVarianceSurface *arg1 = (BlackVarianceSurface *) 0 ;
  
  arg1 = (BlackVarianceSurface *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVarianceSurface__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, int jarg8, char * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BlackVarianceSurface::Extrapolation arg7 ;
  BlackVarianceSurface::Extrapolation arg8 ;
  std::string *arg9 = 0 ;
  BlackVarianceSurfacePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BlackVarianceSurface::Extrapolation)jarg7; 
  arg8 = (BlackVarianceSurface::Extrapolation)jarg8; 
  if (!jarg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg9_str(jarg9);
  arg9 = &arg9_str; 
  {
    try {
      result = (BlackVarianceSurfacePtr *)new_BlackVarianceSurfacePtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(std::string const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVarianceSurface__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BlackVarianceSurface::Extrapolation arg7 ;
  BlackVarianceSurface::Extrapolation arg8 ;
  BlackVarianceSurfacePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BlackVarianceSurface::Extrapolation)jarg7; 
  arg8 = (BlackVarianceSurface::Extrapolation)jarg8; 
  {
    try {
      result = (BlackVarianceSurfacePtr *)new_BlackVarianceSurfacePtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVarianceSurface__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BlackVarianceSurface::Extrapolation arg7 ;
  BlackVarianceSurfacePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BlackVarianceSurface::Extrapolation)jarg7; 
  {
    try {
      result = (BlackVarianceSurfacePtr *)new_BlackVarianceSurfacePtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVarianceSurface__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BlackVarianceSurfacePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackVarianceSurfacePtr *)new_BlackVarianceSurfacePtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackVarianceSurface_setInterpolation__SWIG_0(void * jarg1, char * jarg2) {
  BlackVarianceSurfacePtr *arg1 = (BlackVarianceSurfacePtr *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (BlackVarianceSurfacePtr *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      BlackVarianceSurfacePtr_setInterpolation__SWIG_0(arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackVarianceSurface_setInterpolation__SWIG_1(void * jarg1) {
  BlackVarianceSurfacePtr *arg1 = (BlackVarianceSurfacePtr *) 0 ;
  
  arg1 = (BlackVarianceSurfacePtr *)jarg1; 
  {
    try {
      BlackVarianceSurfacePtr_setInterpolation__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_BlackVarianceSurface_ConstantExtrapolation_get() {
  int jresult ;
  enum BlackVarianceSurface::Extrapolation result;
  
  result = (enum BlackVarianceSurface::Extrapolation)BlackVarianceSurface::ConstantExtrapolation;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_BlackVarianceSurface_InterpolatorDefaultExtrapolation_get() {
  int jresult ;
  enum BlackVarianceSurface::Extrapolation result;
  
  result = (enum BlackVarianceSurface::Extrapolation)BlackVarianceSurface::InterpolatorDefaultExtrapolation;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackVarianceSurface(void * jarg1) {
  BlackVarianceSurfacePtr *arg1 = (BlackVarianceSurfacePtr *) 0 ;
  
  arg1 = (BlackVarianceSurfacePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalConstantVol__SWIG_0(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  LocalConstantVolPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalConstantVolPtr *)new_LocalConstantVolPtr__SWIG_0((Date const &)*arg1,arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalConstantVol__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  LocalConstantVolPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalConstantVolPtr *)new_LocalConstantVolPtr__SWIG_1((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalConstantVol__SWIG_2(int jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Volatility arg3 ;
  DayCounter *arg4 = 0 ;
  LocalConstantVolPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Volatility)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalConstantVolPtr *)new_LocalConstantVolPtr__SWIG_2(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalConstantVol__SWIG_3(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  LocalConstantVolPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalConstantVolPtr *)new_LocalConstantVolPtr__SWIG_3(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LocalConstantVol(void * jarg1) {
  LocalConstantVolPtr *arg1 = (LocalConstantVolPtr *) 0 ;
  
  arg1 = (LocalConstantVolPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolSurface__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  LocalVolSurfacePtr *result = 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalVolSurfacePtr *)new_LocalVolSurfacePtr__SWIG_0((Handle< BlackVolTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolSurface__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Real arg4 ;
  LocalVolSurfacePtr *result = 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (LocalVolSurfacePtr *)new_LocalVolSurfacePtr__SWIG_1((Handle< BlackVolTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LocalVolSurface(void * jarg1) {
  LocalVolSurfacePtr *arg1 = (LocalVolSurfacePtr *) 0 ;
  
  arg1 = (LocalVolSurfacePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_0(void * jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_1(void * jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_2(void * jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_3(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_3((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_4(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_3((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_5(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_3((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_6(unsigned int jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_6(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_7(unsigned int jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_6(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_8(unsigned int jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_6(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_9(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_9(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_10(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_9(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantOptionletVolatility__SWIG_11(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  ConstantOptionletVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantOptionletVolatilityPtr *)new_ConstantOptionletVolatilityPtr__SWIG_9(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConstantOptionletVolatility(void * jarg1) {
  ConstantOptionletVolatilityPtr *arg1 = (ConstantOptionletVolatilityPtr *) 0 ;
  
  arg1 = (ConstantOptionletVolatilityPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_0(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_1(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_2(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_3(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_3((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_4(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_3((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_5(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_3((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_6(unsigned int jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_6(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_7(unsigned int jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_6(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_8(unsigned int jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_6(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_9(void * jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_9((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_10(void * jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_9((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantSwaptionVolatility__SWIG_11(void * jarg1, void * jarg2, int jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  ConstantSwaptionVolatilityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantSwaptionVolatilityPtr *)new_ConstantSwaptionVolatilityPtr__SWIG_9((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConstantSwaptionVolatility(void * jarg1) {
  ConstantSwaptionVolatilityPtr *arg1 = (ConstantSwaptionVolatilityPtr *) 0 ;
  
  arg1 = (ConstantSwaptionVolatilityPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  VolatilityType arg7 ;
  Matrix *arg8 = 0 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Matrix *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< Period > const &)*arg3,(Matrix const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Matrix const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  VolatilityType arg7 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< Period > const &)*arg3,(Matrix const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< Period > const &)*arg3,(Matrix const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< Period > const &)*arg3,(Matrix const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_4(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, int jarg8, void * jarg9) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  VolatilityType arg8 ;
  std::vector< std::vector< Real > > *arg9 = 0 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (std::vector< std::vector< Real > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Real > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_4((Calendar const &)*arg1,arg2,(std::vector< Period > const &)*arg3,(std::vector< Period > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(std::vector< std::vector< double > > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_5(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, int jarg8) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  VolatilityType arg8 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_4((Calendar const &)*arg1,arg2,(std::vector< Period > const &)*arg3,(std::vector< Period > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_6(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_4((Calendar const &)*arg1,arg2,(std::vector< Period > const &)*arg3,(std::vector< Period > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_7(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_4((Calendar const &)*arg1,arg2,(std::vector< Period > const &)*arg3,(std::vector< Period > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_8(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, int jarg8, void * jarg9) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Period > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  VolatilityType arg8 ;
  Matrix *arg9 = 0 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Matrix *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_8((Calendar const &)*arg1,arg2,(std::vector< Period > const &)*arg3,(std::vector< Period > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Matrix const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_9(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, int jarg8) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Period > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  VolatilityType arg8 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_8((Calendar const &)*arg1,arg2,(std::vector< Period > const &)*arg3,(std::vector< Period > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_10(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Period > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_8((Calendar const &)*arg1,arg2,(std::vector< Period > const &)*arg3,(std::vector< Period > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_11(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Period > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  SwaptionVolatilityMatrixPtr *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrixPtr *)new_SwaptionVolatilityMatrixPtr__SWIG_8((Calendar const &)*arg1,arg2,(std::vector< Period > const &)*arg3,(std::vector< Period > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionVolatilityMatrix(void * jarg1) {
  SwaptionVolatilityMatrixPtr *arg1 = (SwaptionVolatilityMatrixPtr *) 0 ;
  
  arg1 = (SwaptionVolatilityMatrixPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolCube1__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8, void * jarg9, void * jarg10, unsigned int jarg11, void * jarg12, double jarg13, void * jarg14) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Spread > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  SwapIndexPtr *arg6 = 0 ;
  SwapIndexPtr *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  boost::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  boost::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  SwaptionVolCube1Ptr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (SwapIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (std::vector< std::vector< Handle< Quote > > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (boost::shared_ptr< EndCriteria > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< EndCriteria > const & type is null", 0);
    return 0;
  } 
  arg13 = (Real)jarg13; 
  arg14 = (boost::shared_ptr< OptimizationMethod > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< OptimizationMethod > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolCube1Ptr *)new_SwaptionVolCube1Ptr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< double > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(SwapIndexPtr const &)*arg6,(SwapIndexPtr const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(boost::shared_ptr< EndCriteria > const &)*arg12,arg13,(boost::shared_ptr< OptimizationMethod > const &)*arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolCube1__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8, void * jarg9, void * jarg10, unsigned int jarg11, void * jarg12, double jarg13) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Spread > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  SwapIndexPtr *arg6 = 0 ;
  SwapIndexPtr *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  boost::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  SwaptionVolCube1Ptr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (SwapIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (std::vector< std::vector< Handle< Quote > > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (boost::shared_ptr< EndCriteria > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< EndCriteria > const & type is null", 0);
    return 0;
  } 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (SwaptionVolCube1Ptr *)new_SwaptionVolCube1Ptr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< double > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(SwapIndexPtr const &)*arg6,(SwapIndexPtr const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(boost::shared_ptr< EndCriteria > const &)*arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolCube1__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8, void * jarg9, void * jarg10, unsigned int jarg11, void * jarg12) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Spread > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  SwapIndexPtr *arg6 = 0 ;
  SwapIndexPtr *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  boost::shared_ptr< EndCriteria > *arg12 = 0 ;
  SwaptionVolCube1Ptr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (SwapIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (std::vector< std::vector< Handle< Quote > > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (boost::shared_ptr< EndCriteria > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< EndCriteria > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolCube1Ptr *)new_SwaptionVolCube1Ptr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< double > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(SwapIndexPtr const &)*arg6,(SwapIndexPtr const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(boost::shared_ptr< EndCriteria > const &)*arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolCube1__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8, void * jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Spread > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  SwapIndexPtr *arg6 = 0 ;
  SwapIndexPtr *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  SwaptionVolCube1Ptr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (SwapIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (std::vector< std::vector< Handle< Quote > > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (SwaptionVolCube1Ptr *)new_SwaptionVolCube1Ptr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< double > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(SwapIndexPtr const &)*arg6,(SwapIndexPtr const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolCube1_sparseSabrParameters(void * jarg1) {
  void * jresult ;
  SwaptionVolCube1Ptr *arg1 = (SwaptionVolCube1Ptr *) 0 ;
  Matrix result;
  
  arg1 = (SwaptionVolCube1Ptr *)jarg1; 
  {
    try {
      result = SwaptionVolCube1Ptr_sparseSabrParameters((SwaptionVolCube1Ptr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolCube1_denseSabrParameters(void * jarg1) {
  void * jresult ;
  SwaptionVolCube1Ptr *arg1 = (SwaptionVolCube1Ptr *) 0 ;
  Matrix result;
  
  arg1 = (SwaptionVolCube1Ptr *)jarg1; 
  {
    try {
      result = SwaptionVolCube1Ptr_denseSabrParameters((SwaptionVolCube1Ptr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolCube1_marketVolCube(void * jarg1) {
  void * jresult ;
  SwaptionVolCube1Ptr *arg1 = (SwaptionVolCube1Ptr *) 0 ;
  Matrix result;
  
  arg1 = (SwaptionVolCube1Ptr *)jarg1; 
  {
    try {
      result = SwaptionVolCube1Ptr_marketVolCube((SwaptionVolCube1Ptr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolCube1_volCubeAtmCalibrated(void * jarg1) {
  void * jresult ;
  SwaptionVolCube1Ptr *arg1 = (SwaptionVolCube1Ptr *) 0 ;
  Matrix result;
  
  arg1 = (SwaptionVolCube1Ptr *)jarg1; 
  {
    try {
      result = SwaptionVolCube1Ptr_volCubeAtmCalibrated((SwaptionVolCube1Ptr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionVolCube1(void * jarg1) {
  SwaptionVolCube1Ptr *arg1 = (SwaptionVolCube1Ptr *) 0 ;
  
  arg1 = (SwaptionVolCube1Ptr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolCube2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period > *arg2 = 0 ;
  std::vector< Period > *arg3 = 0 ;
  std::vector< Spread > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg5 = 0 ;
  SwapIndexPtr *arg6 = 0 ;
  SwapIndexPtr *arg7 = 0 ;
  bool arg8 ;
  SwaptionVolCube2Ptr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< std::vector< Handle< Quote > > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (SwapIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (SwaptionVolCube2Ptr *)new_SwaptionVolCube2Ptr((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< double > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(SwapIndexPtr const &)*arg6,(SwapIndexPtr const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionVolCube2(void * jarg1) {
  SwaptionVolCube2Ptr *arg1 = (SwaptionVolCube2Ptr *) 0 ;
  
  arg1 = (SwaptionVolCube2Ptr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  StochasticProcess *result = 0 ;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  {
    try {
      result = (StochasticProcess *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_StochasticProcess_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_StochasticProcess_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_StochasticProcess_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StochasticProcess() {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< StochasticProcess > *)new boost::shared_ptr< StochasticProcess >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StochasticProcess(void * jarg1) {
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_StochasticProcess_size(void * jarg1) {
  unsigned long jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Size result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  {
    try {
      result = (*arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_StochasticProcess_factors(void * jarg1) {
  unsigned long jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Size result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  {
    try {
      result = (*arg1)->factors();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_initialValues(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Array result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  {
    try {
      result = (*arg1)->initialValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_drift(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Array result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (*arg1)->drift(arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_diffusion(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Matrix result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (*arg1)->diffusion(arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_expectation(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  Array result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (*arg1)->expectation(arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_stdDeviation(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  Matrix result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (*arg1)->stdDeviation(arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_covariance(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  Matrix result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (*arg1)->covariance(arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_evolve(void * jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = (boost::shared_ptr< StochasticProcess > *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  Array *arg5 = 0 ;
  Array result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg4 = (Time)jarg4; 
  arg5 = (Array *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (*arg1)->evolve(arg2,(Array const &)*arg3,arg4,(Array const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  boost::shared_ptr< StochasticProcess > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (boost::shared_ptr< StochasticProcess > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< StochasticProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< boost::shared_ptr< StochasticProcess > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< StochasticProcess > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< boost::shared_ptr< StochasticProcess > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< StochasticProcess > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< boost::shared_ptr< StochasticProcess > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< StochasticProcess > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StochasticProcessVector__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< StochasticProcess > > *)new std::vector< boost::shared_ptr< StochasticProcess > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StochasticProcessVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< StochasticProcess > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< StochasticProcess > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< StochasticProcess > > *)new std::vector< boost::shared_ptr< StochasticProcess > >((std::vector< boost::shared_ptr< StochasticProcess > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StochasticProcessVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< StochasticProcess > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< StochasticProcess > > *)new_std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< StochasticProcess > result;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< StochasticProcess >((const boost::shared_ptr< StochasticProcess > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< StochasticProcess > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< StochasticProcess > *) &std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< StochasticProcess > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< StochasticProcess > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< StochasticProcess > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< StochasticProcess > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< StochasticProcess > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< StochasticProcess > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< StochasticProcess > > *)std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< StochasticProcess > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< StochasticProcess > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< StochasticProcess > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< StochasticProcess > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< StochasticProcess > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< StochasticProcess > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< StochasticProcess > > *)std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Repeat((boost::shared_ptr< StochasticProcess > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< StochasticProcess > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< StochasticProcess > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  boost::shared_ptr< StochasticProcess > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (boost::shared_ptr< StochasticProcess > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Contains(arg1,(boost::shared_ptr< StochasticProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  boost::shared_ptr< StochasticProcess > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (boost::shared_ptr< StochasticProcess > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< StochasticProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  boost::shared_ptr< StochasticProcess > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (boost::shared_ptr< StochasticProcess > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< StochasticProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  boost::shared_ptr< StochasticProcess > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (boost::shared_ptr< StochasticProcess > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_StochasticProcess_Sg__Sg__Remove(arg1,(boost::shared_ptr< StochasticProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StochasticProcessVector(void * jarg1) {
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_x0(void * jarg1) {
  double jresult ;
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  Real result;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  {
    try {
      result = (Real)StochasticProcess1DPtr_x0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_drift(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)StochasticProcess1DPtr_drift(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_diffusion(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)StochasticProcess1DPtr_diffusion(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_expectation(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  Real result;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)StochasticProcess1DPtr_expectation(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_stdDeviation(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  Real result;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)StochasticProcess1DPtr_stdDeviation(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_variance(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  Real result;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)StochasticProcess1DPtr_variance(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_evolve(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Time)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)StochasticProcess1DPtr_evolve(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_apply(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)StochasticProcess1DPtr_apply(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StochasticProcess1D(void * jarg1) {
  StochasticProcess1DPtr *arg1 = (StochasticProcess1DPtr *) 0 ;
  
  arg1 = (StochasticProcess1DPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GeneralizedBlackScholesProcess(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  GeneralizedBlackScholesProcessPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GeneralizedBlackScholesProcessPtr *)new_GeneralizedBlackScholesProcessPtr((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_stateVariable(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = (GeneralizedBlackScholesProcessPtr *) 0 ;
  Handle< Quote > result;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1; 
  {
    try {
      result = GeneralizedBlackScholesProcessPtr_stateVariable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< Quote >((const Handle< Quote > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_dividendYield(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = (GeneralizedBlackScholesProcessPtr *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1; 
  {
    try {
      result = GeneralizedBlackScholesProcessPtr_dividendYield(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_riskFreeRate(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = (GeneralizedBlackScholesProcessPtr *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1; 
  {
    try {
      result = GeneralizedBlackScholesProcessPtr_riskFreeRate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_blackVolatility(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = (GeneralizedBlackScholesProcessPtr *) 0 ;
  Handle< BlackVolTermStructure > result;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1; 
  {
    try {
      result = GeneralizedBlackScholesProcessPtr_blackVolatility((GeneralizedBlackScholesProcessPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< BlackVolTermStructure >((const Handle< BlackVolTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GeneralizedBlackScholesProcess(void * jarg1) {
  GeneralizedBlackScholesProcessPtr *arg1 = (GeneralizedBlackScholesProcessPtr *) 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackScholesProcess(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  BlackScholesProcessPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< BlackVolTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackScholesProcessPtr *)new_BlackScholesProcessPtr((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< BlackVolTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackScholesProcess(void * jarg1) {
  BlackScholesProcessPtr *arg1 = (BlackScholesProcessPtr *) 0 ;
  
  arg1 = (BlackScholesProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackScholesMertonProcess(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  BlackScholesMertonProcessPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackScholesMertonProcessPtr *)new_BlackScholesMertonProcessPtr((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackScholesMertonProcess(void * jarg1) {
  BlackScholesMertonProcessPtr *arg1 = (BlackScholesMertonProcessPtr *) 0 ;
  
  arg1 = (BlackScholesMertonProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackProcess(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  BlackProcessPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< BlackVolTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackProcessPtr *)new_BlackProcessPtr((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< BlackVolTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackProcess(void * jarg1) {
  BlackProcessPtr *arg1 = (BlackProcessPtr *) 0 ;
  
  arg1 = (BlackProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GarmanKohlagenProcess(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  GarmanKohlagenProcessPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GarmanKohlagenProcessPtr *)new_GarmanKohlagenProcessPtr((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GarmanKohlagenProcess(void * jarg1) {
  GarmanKohlagenProcessPtr *arg1 = (GarmanKohlagenProcessPtr *) 0 ;
  
  arg1 = (GarmanKohlagenProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Merton76Process(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< Quote > *arg7 = 0 ;
  Merton76ProcessPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Handle< Quote > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< Quote > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Merton76ProcessPtr *)new_Merton76ProcessPtr((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4,(Handle< Quote > const &)*arg5,(Handle< Quote > const &)*arg6,(Handle< Quote > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Merton76Process(void * jarg1) {
  Merton76ProcessPtr *arg1 = (Merton76ProcessPtr *) 0 ;
  
  arg1 = (Merton76ProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StochasticProcessArray(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< StochasticProcess > > *arg1 = 0 ;
  Matrix *arg2 = 0 ;
  StochasticProcessArrayPtr *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< StochasticProcess > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< StochasticProcess > > const & type is null", 0);
    return 0;
  } 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (StochasticProcessArrayPtr *)new_StochasticProcessArrayPtr((std::vector< boost::shared_ptr< StochasticProcess > > const &)*arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StochasticProcessArray(void * jarg1) {
  StochasticProcessArrayPtr *arg1 = (StochasticProcessArrayPtr *) 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GeometricBrownianMotionProcess(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  GeometricBrownianMotionProcessPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (GeometricBrownianMotionProcessPtr *)new_GeometricBrownianMotionProcessPtr(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GeometricBrownianMotionProcess(void * jarg1) {
  GeometricBrownianMotionProcessPtr *arg1 = (GeometricBrownianMotionProcessPtr *) 0 ;
  
  arg1 = (GeometricBrownianMotionProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VarianceGammaProcess(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  VarianceGammaProcessPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (VarianceGammaProcessPtr *)new_VarianceGammaProcessPtr((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VarianceGammaProcess(void * jarg1) {
  VarianceGammaProcessPtr *arg1 = (VarianceGammaProcessPtr *) 0 ;
  
  arg1 = (VarianceGammaProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonProcess(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  HestonProcessPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (HestonProcessPtr *)new_HestonProcessPtr((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonProcess_s0(void * jarg1) {
  void * jresult ;
  HestonProcessPtr *arg1 = (HestonProcessPtr *) 0 ;
  Handle< Quote > result;
  
  arg1 = (HestonProcessPtr *)jarg1; 
  {
    try {
      result = HestonProcessPtr_s0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< Quote >((const Handle< Quote > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonProcess_dividendYield(void * jarg1) {
  void * jresult ;
  HestonProcessPtr *arg1 = (HestonProcessPtr *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (HestonProcessPtr *)jarg1; 
  {
    try {
      result = HestonProcessPtr_dividendYield(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonProcess_riskFreeRate(void * jarg1) {
  void * jresult ;
  HestonProcessPtr *arg1 = (HestonProcessPtr *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (HestonProcessPtr *)jarg1; 
  {
    try {
      result = HestonProcessPtr_riskFreeRate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonProcess(void * jarg1) {
  HestonProcessPtr *arg1 = (HestonProcessPtr *) 0 ;
  
  arg1 = (HestonProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BatesProcess(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  BatesProcessPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (BatesProcessPtr *)new_BatesProcessPtr((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BatesProcess(void * jarg1) {
  BatesProcessPtr *arg1 = (BatesProcessPtr *) 0 ;
  
  arg1 = (BatesProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HullWhiteProcess(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  HullWhiteProcessPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (HullWhiteProcessPtr *)new_HullWhiteProcessPtr((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HullWhiteProcess(void * jarg1) {
  HullWhiteProcessPtr *arg1 = (HullWhiteProcessPtr *) 0 ;
  
  arg1 = (HullWhiteProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HullWhiteForwardProcess(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  HullWhiteForwardProcessPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (HullWhiteForwardProcessPtr *)new_HullWhiteForwardProcessPtr((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HullWhiteForwardProcess_alpha(void * jarg1, double jarg2) {
  double jresult ;
  HullWhiteForwardProcessPtr *arg1 = (HullWhiteForwardProcessPtr *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (HullWhiteForwardProcessPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)HullWhiteForwardProcessPtr_alpha((HullWhiteForwardProcessPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HullWhiteForwardProcess_M_T(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  HullWhiteForwardProcessPtr *arg1 = (HullWhiteForwardProcessPtr *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (HullWhiteForwardProcessPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)HullWhiteForwardProcessPtr_M_T((HullWhiteForwardProcessPtr const *)arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HullWhiteForwardProcess_B(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  HullWhiteForwardProcessPtr *arg1 = (HullWhiteForwardProcessPtr *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (HullWhiteForwardProcessPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)HullWhiteForwardProcessPtr_B((HullWhiteForwardProcessPtr const *)arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_HullWhiteForwardProcess_setForwardMeasureTime(void * jarg1, double jarg2) {
  HullWhiteForwardProcessPtr *arg1 = (HullWhiteForwardProcessPtr *) 0 ;
  Time arg2 ;
  
  arg1 = (HullWhiteForwardProcessPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      HullWhiteForwardProcessPtr_setForwardMeasureTime(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HullWhiteForwardProcess(void * jarg1) {
  HullWhiteForwardProcessPtr *arg1 = (HullWhiteForwardProcessPtr *) 0 ;
  
  arg1 = (HullWhiteForwardProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GsrProcess__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  GsrProcessPtr *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (GsrProcessPtr *)new_GsrProcessPtr__SWIG_0((Array const &)*arg1,(Array const &)*arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GsrProcess__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  GsrProcessPtr *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GsrProcessPtr *)new_GsrProcessPtr__SWIG_0((Array const &)*arg1,(Array const &)*arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GsrProcess_sigma(void * jarg1, double jarg2) {
  double jresult ;
  GsrProcessPtr *arg1 = (GsrProcessPtr *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (GsrProcessPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)GsrProcessPtr_sigma(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GsrProcess_reversion(void * jarg1, double jarg2) {
  double jresult ;
  GsrProcessPtr *arg1 = (GsrProcessPtr *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (GsrProcessPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)GsrProcessPtr_reversion(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GsrProcess_y(void * jarg1, double jarg2) {
  double jresult ;
  GsrProcessPtr *arg1 = (GsrProcessPtr *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (GsrProcessPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)GsrProcessPtr_y(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GsrProcess_G(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  GsrProcessPtr *arg1 = (GsrProcessPtr *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (GsrProcessPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)GsrProcessPtr_G(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_GsrProcess_setForwardMeasureTime(void * jarg1, double jarg2) {
  GsrProcessPtr *arg1 = (GsrProcessPtr *) 0 ;
  Time arg2 ;
  
  arg1 = (GsrProcessPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      GsrProcessPtr_setForwardMeasureTime(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GsrProcess(void * jarg1) {
  GsrProcessPtr *arg1 = (GsrProcessPtr *) 0 ;
  
  arg1 = (GsrProcessPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_gsr_process(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = 0 ;
  SwigValueWrapper< GsrProcessPtr > result;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = as_gsr_process((boost::shared_ptr< StochasticProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new GsrProcessPtr((const GsrProcessPtr &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PricingEngine___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< PricingEngine > *arg1 = (boost::shared_ptr< PricingEngine > *) 0 ;
  PricingEngine *result = 0 ;
  
  arg1 = (boost::shared_ptr< PricingEngine > *)jarg1; 
  {
    try {
      result = (PricingEngine *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_PricingEngine_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< PricingEngine > *arg1 = (boost::shared_ptr< PricingEngine > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< PricingEngine > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_PricingEngine_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PricingEngine() {
  void * jresult ;
  boost::shared_ptr< PricingEngine > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< PricingEngine > *)new boost::shared_ptr< PricingEngine >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PricingEngine(void * jarg1) {
  boost::shared_ptr< PricingEngine > *arg1 = (boost::shared_ptr< PricingEngine > *) 0 ;
  
  arg1 = (boost::shared_ptr< PricingEngine > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Instrument___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  Instrument *result = 0 ;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      result = (Instrument *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Instrument_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Instrument_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Instrument_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_Instrument_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Instrument() {
  void * jresult ;
  boost::shared_ptr< Instrument > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Instrument > *)new boost::shared_ptr< Instrument >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Instrument(void * jarg1) {
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Instrument_NPV(void * jarg1) {
  double jresult ;
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->NPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Instrument_errorEstimate(void * jarg1) {
  double jresult ;
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Instrument_isExpired(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->isExpired();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Instrument_setPricingEngine(void * jarg1, void * jarg2) {
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  boost::shared_ptr< PricingEngine > *arg2 = 0 ;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  arg2 = (boost::shared_ptr< PricingEngine > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< PricingEngine > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setPricingEngine((boost::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Instrument_recalculate(void * jarg1) {
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      (*arg1)->recalculate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Instrument_freeze(void * jarg1) {
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      (*arg1)->freeze();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Instrument_unfreeze(void * jarg1) {
  boost::shared_ptr< Instrument > *arg1 = (boost::shared_ptr< Instrument > *) 0 ;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1; 
  {
    try {
      (*arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InstrumentVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  std::vector< boost::shared_ptr< Instrument > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< Instrument > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InstrumentVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  std::vector< boost::shared_ptr< Instrument > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< Instrument > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  std::vector< boost::shared_ptr< Instrument > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Instrument > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InstrumentVector__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< Instrument > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< Instrument > > *)new std::vector< boost::shared_ptr< Instrument > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InstrumentVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< Instrument > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Instrument > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< Instrument > > *)new std::vector< boost::shared_ptr< Instrument > >((std::vector< boost::shared_ptr< Instrument > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InstrumentVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< Instrument > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Instrument > > *)new_std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InstrumentVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Instrument > result;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Instrument >((const boost::shared_ptr< Instrument > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InstrumentVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Instrument > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< Instrument > *) &std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Instrument > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< Instrument > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< Instrument > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  std::vector< boost::shared_ptr< Instrument > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Instrument > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Instrument > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< Instrument > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InstrumentVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< Instrument > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Instrument > > *)std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Instrument > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< Instrument > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< Instrument > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Instrument > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Instrument > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Instrument > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< Instrument > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InstrumentVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< Instrument > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Instrument > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< Instrument > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Instrument > > *)std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Repeat((boost::shared_ptr< Instrument > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Instrument > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Instrument > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Instrument > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< Instrument > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_InstrumentVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Contains(arg1,(boost::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_InstrumentVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_InstrumentVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_InstrumentVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_Instrument_Sg__Sg__Remove(arg1,(boost::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InstrumentVector(void * jarg1) {
  std::vector< boost::shared_ptr< Instrument > > *arg1 = (std::vector< boost::shared_ptr< Instrument > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Instrument > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Stock(void * jarg1) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  StockPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (StockPtr *)new_StockPtr((Handle< Quote > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Stock(void * jarg1) {
  StockPtr *arg1 = (StockPtr *) 0 ;
  
  arg1 = (StockPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CompositeInstrument() {
  void * jresult ;
  CompositeInstrumentPtr *result = 0 ;
  
  {
    try {
      result = (CompositeInstrumentPtr *)new_CompositeInstrumentPtr();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CompositeInstrument_add__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  CompositeInstrumentPtr *arg1 = (CompositeInstrumentPtr *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  Real arg3 ;
  
  arg1 = (CompositeInstrumentPtr *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      CompositeInstrumentPtr_add__SWIG_0(arg1,(boost::shared_ptr< Instrument > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CompositeInstrument_add__SWIG_1(void * jarg1, void * jarg2) {
  CompositeInstrumentPtr *arg1 = (CompositeInstrumentPtr *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  
  arg1 = (CompositeInstrumentPtr *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return ;
  } 
  {
    try {
      CompositeInstrumentPtr_add__SWIG_0(arg1,(boost::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CompositeInstrument_subtract__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  CompositeInstrumentPtr *arg1 = (CompositeInstrumentPtr *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  Real arg3 ;
  
  arg1 = (CompositeInstrumentPtr *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      CompositeInstrumentPtr_subtract__SWIG_0(arg1,(boost::shared_ptr< Instrument > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CompositeInstrument_subtract__SWIG_1(void * jarg1, void * jarg2) {
  CompositeInstrumentPtr *arg1 = (CompositeInstrumentPtr *) 0 ;
  boost::shared_ptr< Instrument > *arg2 = 0 ;
  
  arg1 = (CompositeInstrumentPtr *)jarg1; 
  arg2 = (boost::shared_ptr< Instrument > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Instrument > const & type is null", 0);
    return ;
  } 
  {
    try {
      CompositeInstrumentPtr_subtract__SWIG_0(arg1,(boost::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CompositeInstrument(void * jarg1) {
  CompositeInstrumentPtr *arg1 = (CompositeInstrumentPtr *) 0 ;
  
  arg1 = (CompositeInstrumentPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DateGeneration() {
  void * jresult ;
  DateGeneration *result = 0 ;
  
  {
    try {
      result = (DateGeneration *)new DateGeneration();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DateGeneration(void * jarg1) {
  DateGeneration *arg1 = (DateGeneration *) 0 ;
  
  arg1 = (DateGeneration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Schedule__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Schedule *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date > const &)*arg1,(Calendar const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Schedule__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Schedule *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date > const &)*arg1,(Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Schedule__SWIG_2(void * jarg1) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  Schedule *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Schedule__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, unsigned int jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  Schedule *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Schedule *)new Schedule((Date const &)*arg1,(Date const &)*arg2,(Period const &)*arg3,(Calendar const &)*arg4,arg5,arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Schedule__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, unsigned int jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  Schedule *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Schedule *)new Schedule((Date const &)*arg1,(Date const &)*arg2,(Period const &)*arg3,(Calendar const &)*arg4,arg5,arg6,arg7,arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Schedule__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, unsigned int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  bool arg8 ;
  Schedule *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (Schedule *)new Schedule((Date const &)*arg1,(Date const &)*arg2,(Period const &)*arg3,(Calendar const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Schedule__SWIG_6() {
  void * jresult ;
  Schedule *result = 0 ;
  
  {
    try {
      result = (Schedule *)new Schedule();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Schedule_size(void * jarg1) {
  unsigned long jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Size result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = ((Schedule const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Schedule_date(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Size arg2 ;
  Date result;
  
  arg1 = (Schedule *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = ((Schedule const *)arg1)->date(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Schedule_isRegular(void * jarg1, unsigned long jarg2) {
  unsigned int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Size arg2 ;
  bool result;
  
  arg1 = (Schedule *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (bool)((Schedule const *)arg1)->isRegular(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Schedule_until(void * jarg1, void * jarg2) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Date arg2 ;
  Date *argp2 ;
  Schedule result;
  
  arg1 = (Schedule *)jarg1; 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = ((Schedule const *)arg1)->until(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Schedule((const Schedule &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Schedule(void * jarg1) {
  Schedule *arg1 = (Schedule *) 0 ;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlow___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CashFlow > *arg1 = (boost::shared_ptr< CashFlow > *) 0 ;
  CashFlow *result = 0 ;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1; 
  {
    try {
      result = (CashFlow *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CashFlow_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< CashFlow > *arg1 = (boost::shared_ptr< CashFlow > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_CashFlow_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlow_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CashFlow > *arg1 = (boost::shared_ptr< CashFlow > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_CashFlow_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CashFlow() {
  void * jresult ;
  boost::shared_ptr< CashFlow > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< CashFlow > *)new boost::shared_ptr< CashFlow >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CashFlow(void * jarg1) {
  boost::shared_ptr< CashFlow > *arg1 = (boost::shared_ptr< CashFlow > *) 0 ;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlow_amount(void * jarg1) {
  double jresult ;
  boost::shared_ptr< CashFlow > *arg1 = (boost::shared_ptr< CashFlow > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->amount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlow_date(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CashFlow > *arg1 = (boost::shared_ptr< CashFlow > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1; 
  {
    try {
      result = (*arg1)->date();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  boost::shared_ptr< CashFlow > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (boost::shared_ptr< CashFlow > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< CashFlow > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Leg_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< CashFlow > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Leg_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< CashFlow > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CashFlow > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Leg__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< CashFlow > > *)new std::vector< boost::shared_ptr< CashFlow > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Leg__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< CashFlow > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< CashFlow > > *)new std::vector< boost::shared_ptr< CashFlow > >((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Leg__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< CashFlow > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< CashFlow > > *)new_std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Leg_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< CashFlow > result;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< CashFlow >((const boost::shared_ptr< CashFlow > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Leg_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< CashFlow > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< CashFlow > *) &std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< CashFlow > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< CashFlow > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< CashFlow > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< CashFlow > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Leg_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< CashFlow > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< CashFlow > > *)std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< CashFlow > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< CashFlow > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< CashFlow > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< CashFlow > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< CashFlow > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Leg_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< CashFlow > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< CashFlow > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< CashFlow > > *)std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Repeat((boost::shared_ptr< CashFlow > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< CashFlow > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< CashFlow > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Leg_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  boost::shared_ptr< CashFlow > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (boost::shared_ptr< CashFlow > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Contains(arg1,(boost::shared_ptr< CashFlow > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Leg_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  boost::shared_ptr< CashFlow > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (boost::shared_ptr< CashFlow > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< CashFlow > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Leg_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  boost::shared_ptr< CashFlow > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (boost::shared_ptr< CashFlow > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< CashFlow > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Leg_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  boost::shared_ptr< CashFlow > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (boost::shared_ptr< CashFlow > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_CashFlow_Sg__Sg__Remove(arg1,(boost::shared_ptr< CashFlow > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Leg(void * jarg1) {
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = (std::vector< boost::shared_ptr< CashFlow > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SimpleCashFlow(double jarg1, void * jarg2) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  SimpleCashFlowPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SimpleCashFlowPtr *)new_SimpleCashFlowPtr(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SimpleCashFlow(void * jarg1) {
  SimpleCashFlowPtr *arg1 = (SimpleCashFlowPtr *) 0 ;
  
  arg1 = (SimpleCashFlowPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Redemption(double jarg1, void * jarg2) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  RedemptionPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RedemptionPtr *)new_RedemptionPtr(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Redemption(void * jarg1) {
  RedemptionPtr *arg1 = (RedemptionPtr *) 0 ;
  
  arg1 = (RedemptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingPayment(double jarg1, void * jarg2) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  AmortizingPaymentPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingPaymentPtr *)new_AmortizingPaymentPtr(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AmortizingPayment(void * jarg1) {
  AmortizingPaymentPtr *arg1 = (AmortizingPaymentPtr *) 0 ;
  
  arg1 = (AmortizingPaymentPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Coupon_nominal(void * jarg1) {
  double jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Real result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = (Real)CouponPtr_nominal(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_accrualStartDate(void * jarg1) {
  void * jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Date result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = CouponPtr_accrualStartDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_accrualEndDate(void * jarg1) {
  void * jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Date result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = CouponPtr_accrualEndDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_referencePeriodStart(void * jarg1) {
  void * jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Date result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = CouponPtr_referencePeriodStart(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_referencePeriodEnd(void * jarg1) {
  void * jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Date result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = CouponPtr_referencePeriodEnd(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_exCouponDate(void * jarg1) {
  void * jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Date result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = CouponPtr_exCouponDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Coupon_rate(void * jarg1) {
  double jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Real result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = (Real)CouponPtr_rate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Coupon_accrualPeriod(void * jarg1) {
  double jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Time result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = (Time)CouponPtr_accrualPeriod(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_Coupon_accrualDays(void * jarg1) {
  long jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  BigInteger result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = (BigInteger)CouponPtr_accrualDays(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_dayCounter(void * jarg1) {
  void * jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      result = CouponPtr_dayCounter((CouponPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Coupon_accruedAmount(void * jarg1, void * jarg2) {
  double jresult ;
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (CouponPtr *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CouponPtr_accruedAmount(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Coupon(void * jarg1) {
  CouponPtr *arg1 = (CouponPtr *) 0 ;
  
  arg1 = (CouponPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_coupon(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CashFlow > *arg1 = 0 ;
  SwigValueWrapper< CouponPtr > result;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = as_coupon((boost::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new CouponPtr((const CouponPtr &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateCoupon__SWIG_0(void * jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  FixedRateCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateCouponPtr *)new_FixedRateCouponPtr__SWIG_0((Date const &)*arg1,arg2,arg3,(DayCounter const &)*arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7,(Date const &)*arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateCoupon__SWIG_1(void * jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  Date *arg8 = 0 ;
  FixedRateCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateCouponPtr *)new_FixedRateCouponPtr__SWIG_0((Date const &)*arg1,arg2,arg3,(DayCounter const &)*arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateCoupon__SWIG_2(void * jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  FixedRateCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateCouponPtr *)new_FixedRateCouponPtr__SWIG_0((Date const &)*arg1,arg2,arg3,(DayCounter const &)*arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateCoupon__SWIG_3(void * jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  FixedRateCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateCouponPtr *)new_FixedRateCouponPtr__SWIG_0((Date const &)*arg1,arg2,arg3,(DayCounter const &)*arg4,(Date const &)*arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateCoupon_interestRate(void * jarg1) {
  void * jresult ;
  FixedRateCouponPtr *arg1 = (FixedRateCouponPtr *) 0 ;
  InterestRate result;
  
  arg1 = (FixedRateCouponPtr *)jarg1; 
  {
    try {
      result = FixedRateCouponPtr_interestRate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedRateCoupon(void * jarg1) {
  FixedRateCouponPtr *arg1 = (FixedRateCouponPtr *) 0 ;
  
  arg1 = (FixedRateCouponPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_fixed_rate_coupon(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CashFlow > *arg1 = 0 ;
  SwigValueWrapper< FixedRateCouponPtr > result;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = as_fixed_rate_coupon((boost::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FixedRateCouponPtr((const FixedRateCouponPtr &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FloatingRateCouponPricer___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< FloatingRateCouponPricer > *arg1 = (boost::shared_ptr< FloatingRateCouponPricer > *) 0 ;
  FloatingRateCouponPricer *result = 0 ;
  
  arg1 = (boost::shared_ptr< FloatingRateCouponPricer > *)jarg1; 
  {
    try {
      result = (FloatingRateCouponPricer *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_FloatingRateCouponPricer_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< FloatingRateCouponPricer > *arg1 = (boost::shared_ptr< FloatingRateCouponPricer > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< FloatingRateCouponPricer > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_FloatingRateCouponPricer_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateCouponPricer() {
  void * jresult ;
  boost::shared_ptr< FloatingRateCouponPricer > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< FloatingRateCouponPricer > *)new boost::shared_ptr< FloatingRateCouponPricer >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloatingRateCouponPricer(void * jarg1) {
  boost::shared_ptr< FloatingRateCouponPricer > *arg1 = (boost::shared_ptr< FloatingRateCouponPricer > *) 0 ;
  
  arg1 = (boost::shared_ptr< FloatingRateCouponPricer > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_setCouponPricer(void * jarg1, void * jarg2) {
  Leg *arg1 = 0 ;
  boost::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return ;
  } 
  arg2 = (boost::shared_ptr< FloatingRateCouponPricer > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< FloatingRateCouponPricer > const & type is null", 0);
    return ;
  } 
  {
    try {
      setCouponPricer((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< FloatingRateCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_fixingDate(void * jarg1) {
  void * jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  Date result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = FloatingRateCouponPtr_fixingDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_fixingDays(void * jarg1) {
  int jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  Integer result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = (Integer)FloatingRateCouponPtr_fixingDays(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_isInArrears(void * jarg1) {
  unsigned int jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  bool result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = (bool)FloatingRateCouponPtr_isInArrears(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_gearing(void * jarg1) {
  double jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  Real result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = (Real)FloatingRateCouponPtr_gearing(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_spread(void * jarg1) {
  double jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  Rate result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = (Rate)FloatingRateCouponPtr_spread(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_indexFixing(void * jarg1) {
  double jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  Rate result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = (Rate)FloatingRateCouponPtr_indexFixing(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_adjustedFixing(void * jarg1) {
  double jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  Rate result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = (Rate)FloatingRateCouponPtr_adjustedFixing(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_convexityAdjustment(void * jarg1) {
  double jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  Rate result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = (Rate)FloatingRateCouponPtr_convexityAdjustment(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_price(void * jarg1, void * jarg2) {
  double jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Real result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)FloatingRateCouponPtr_price(arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_index(void * jarg1) {
  void * jresult ;
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  SwigValueWrapper< InterestRateIndexPtr > result;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      result = FloatingRateCouponPtr_index((FloatingRateCouponPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRateIndexPtr((const InterestRateIndexPtr &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_setPricer(void * jarg1, void * jarg2) {
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  boost::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  arg2 = (boost::shared_ptr< FloatingRateCouponPricer > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< FloatingRateCouponPricer > const & type is null", 0);
    return ;
  } 
  {
    try {
      FloatingRateCouponPtr_setPricer(arg1,(boost::shared_ptr< FloatingRateCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloatingRateCoupon(void * jarg1) {
  FloatingRateCouponPtr *arg1 = (FloatingRateCouponPtr *) 0 ;
  
  arg1 = (FloatingRateCouponPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_floating_rate_coupon(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CashFlow > *arg1 = 0 ;
  SwigValueWrapper< FloatingRateCouponPtr > result;
  
  arg1 = (boost::shared_ptr< CashFlow > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CashFlow > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = as_floating_rate_coupon((boost::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FloatingRateCouponPtr((const FloatingRateCouponPtr &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCoupon__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  FloatingRateCouponPtr *arg1 = 0 ;
  Rate arg2 ;
  Rate arg3 ;
  CappedFlooredCouponPtr *result = 0 ;
  
  arg1 = (FloatingRateCouponPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FloatingRateCouponPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (CappedFlooredCouponPtr *)new_CappedFlooredCouponPtr__SWIG_0((FloatingRateCouponPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCoupon__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  FloatingRateCouponPtr *arg1 = 0 ;
  Rate arg2 ;
  CappedFlooredCouponPtr *result = 0 ;
  
  arg1 = (FloatingRateCouponPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FloatingRateCouponPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (CappedFlooredCouponPtr *)new_CappedFlooredCouponPtr__SWIG_0((FloatingRateCouponPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCoupon__SWIG_2(void * jarg1) {
  void * jresult ;
  FloatingRateCouponPtr *arg1 = 0 ;
  CappedFlooredCouponPtr *result = 0 ;
  
  arg1 = (FloatingRateCouponPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FloatingRateCouponPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCouponPtr *)new_CappedFlooredCouponPtr__SWIG_0((FloatingRateCouponPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_cap(void * jarg1) {
  double jresult ;
  CappedFlooredCouponPtr *arg1 = (CappedFlooredCouponPtr *) 0 ;
  Rate result;
  
  arg1 = (CappedFlooredCouponPtr *)jarg1; 
  {
    try {
      result = (Rate)CappedFlooredCouponPtr_cap(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_floor(void * jarg1) {
  double jresult ;
  CappedFlooredCouponPtr *arg1 = (CappedFlooredCouponPtr *) 0 ;
  Rate result;
  
  arg1 = (CappedFlooredCouponPtr *)jarg1; 
  {
    try {
      result = (Rate)CappedFlooredCouponPtr_floor(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_effectiveCap(void * jarg1) {
  double jresult ;
  CappedFlooredCouponPtr *arg1 = (CappedFlooredCouponPtr *) 0 ;
  Rate result;
  
  arg1 = (CappedFlooredCouponPtr *)jarg1; 
  {
    try {
      result = (Rate)CappedFlooredCouponPtr_effectiveCap(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_effectiveFloor(void * jarg1) {
  double jresult ;
  CappedFlooredCouponPtr *arg1 = (CappedFlooredCouponPtr *) 0 ;
  Rate result;
  
  arg1 = (CappedFlooredCouponPtr *)jarg1; 
  {
    try {
      result = (Rate)CappedFlooredCouponPtr_effectiveFloor(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_isCapped(void * jarg1) {
  unsigned int jresult ;
  CappedFlooredCouponPtr *arg1 = (CappedFlooredCouponPtr *) 0 ;
  bool result;
  
  arg1 = (CappedFlooredCouponPtr *)jarg1; 
  {
    try {
      result = (bool)CappedFlooredCouponPtr_isCapped(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_isFloored(void * jarg1) {
  unsigned int jresult ;
  CappedFlooredCouponPtr *arg1 = (CappedFlooredCouponPtr *) 0 ;
  bool result;
  
  arg1 = (CappedFlooredCouponPtr *)jarg1; 
  {
    try {
      result = (bool)CappedFlooredCouponPtr_isFloored(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_setPricer(void * jarg1, void * jarg2) {
  CappedFlooredCouponPtr *arg1 = (CappedFlooredCouponPtr *) 0 ;
  boost::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  
  arg1 = (CappedFlooredCouponPtr *)jarg1; 
  arg2 = (boost::shared_ptr< FloatingRateCouponPricer > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< FloatingRateCouponPricer > const & type is null", 0);
    return ;
  } 
  {
    try {
      CappedFlooredCouponPtr_setPricer(arg1,(boost::shared_ptr< FloatingRateCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CappedFlooredCoupon(void * jarg1) {
  CappedFlooredCouponPtr *arg1 = (CappedFlooredCouponPtr *) 0 ;
  
  arg1 = (CappedFlooredCouponPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  InterestRateIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  IborCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (InterestRateIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborCouponPtr *)new_IborCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  InterestRateIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  IborCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (InterestRateIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborCouponPtr *)new_IborCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  InterestRateIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  IborCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (InterestRateIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborCouponPtr *)new_IborCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7,arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  InterestRateIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  IborCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (InterestRateIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (IborCouponPtr *)new_IborCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  InterestRateIndexPtr *arg6 = 0 ;
  Real arg7 ;
  IborCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (InterestRateIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (IborCouponPtr *)new_IborCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  InterestRateIndexPtr *arg6 = 0 ;
  IborCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (InterestRateIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborCouponPtr *)new_IborCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IborCoupon(void * jarg1) {
  IborCouponPtr *arg1 = (IborCouponPtr *) 0 ;
  
  arg1 = (IborCouponPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborCouponPricer_capletVolatility(void * jarg1) {
  void * jresult ;
  IborCouponPricerPtr *arg1 = (IborCouponPricerPtr *) 0 ;
  Handle< OptionletVolatilityStructure > result;
  
  arg1 = (IborCouponPricerPtr *)jarg1; 
  {
    try {
      result = IborCouponPricerPtr_capletVolatility(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< OptionletVolatilityStructure >((const Handle< OptionletVolatilityStructure > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IborCouponPricer_setCapletVolatility__SWIG_0(void * jarg1, void * jarg2) {
  IborCouponPricerPtr *arg1 = (IborCouponPricerPtr *) 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  
  arg1 = (IborCouponPricerPtr *)jarg1; 
  arg2 = (Handle< OptionletVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      IborCouponPricerPtr_setCapletVolatility__SWIG_0(arg1,(Handle< OptionletVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IborCouponPricer_setCapletVolatility__SWIG_1(void * jarg1) {
  IborCouponPricerPtr *arg1 = (IborCouponPricerPtr *) 0 ;
  
  arg1 = (IborCouponPricerPtr *)jarg1; 
  {
    try {
      IborCouponPricerPtr_setCapletVolatility__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IborCouponPricer(void * jarg1) {
  IborCouponPricerPtr *arg1 = (IborCouponPricerPtr *) 0 ;
  
  arg1 = (IborCouponPricerPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackIborCouponPricer__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = 0 ;
  BlackIborCouponPricerPtr *result = 0 ;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackIborCouponPricerPtr *)new_BlackIborCouponPricerPtr__SWIG_0((Handle< OptionletVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackIborCouponPricer__SWIG_1() {
  void * jresult ;
  BlackIborCouponPricerPtr *result = 0 ;
  
  {
    try {
      result = (BlackIborCouponPricerPtr *)new_BlackIborCouponPricerPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackIborCouponPricer(void * jarg1) {
  BlackIborCouponPricerPtr *arg1 = (BlackIborCouponPricerPtr *) 0 ;
  
  arg1 = (BlackIborCouponPricerPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  CmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (CmsCouponPtr *)new_CmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  CmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsCouponPtr *)new_CmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  CmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsCouponPtr *)new_CmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  CmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsCouponPtr *)new_CmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  CmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (CmsCouponPtr *)new_CmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  CmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (CmsCouponPtr *)new_CmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_6(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  CmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsCouponPtr *)new_CmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CmsCoupon(void * jarg1) {
  CmsCouponPtr *arg1 = (CmsCouponPtr *) 0 ;
  
  arg1 = (CmsCouponPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsCouponPricer_swaptionVolatility(void * jarg1) {
  void * jresult ;
  CmsCouponPricerPtr *arg1 = (CmsCouponPricerPtr *) 0 ;
  Handle< SwaptionVolatilityStructure > result;
  
  arg1 = (CmsCouponPricerPtr *)jarg1; 
  {
    try {
      result = CmsCouponPricerPtr_swaptionVolatility(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< SwaptionVolatilityStructure >((const Handle< SwaptionVolatilityStructure > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CmsCouponPricer_setSwaptionVolatility__SWIG_0(void * jarg1, void * jarg2) {
  CmsCouponPricerPtr *arg1 = (CmsCouponPricerPtr *) 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  
  arg1 = (CmsCouponPricerPtr *)jarg1; 
  arg2 = (Handle< SwaptionVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      CmsCouponPricerPtr_setSwaptionVolatility__SWIG_0(arg1,(Handle< SwaptionVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CmsCouponPricer_setSwaptionVolatility__SWIG_1(void * jarg1) {
  CmsCouponPricerPtr *arg1 = (CmsCouponPricerPtr *) 0 ;
  
  arg1 = (CmsCouponPricerPtr *)jarg1; 
  {
    try {
      CmsCouponPricerPtr_setSwaptionVolatility__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CmsCouponPricer(void * jarg1) {
  CmsCouponPricerPtr *arg1 = (CmsCouponPricerPtr *) 0 ;
  
  arg1 = (CmsCouponPricerPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GFunctionFactory(void * jarg1) {
  GFunctionFactory *arg1 = (GFunctionFactory *) 0 ;
  
  arg1 = (GFunctionFactory *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHaganPricer(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  AnalyticHaganPricerPtr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticHaganPricerPtr *)new_AnalyticHaganPricerPtr((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticHaganPricer(void * jarg1) {
  AnalyticHaganPricerPtr *arg1 = (AnalyticHaganPricerPtr *) 0 ;
  
  arg1 = (AnalyticHaganPricerPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NumericHaganPricer__SWIG_0(void * jarg1, int jarg2, void * jarg3, double jarg4, double jarg5, double jarg6) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  Rate arg4 ;
  Rate arg5 ;
  Real arg6 ;
  NumericHaganPricerPtr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (Rate)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (NumericHaganPricerPtr *)new_NumericHaganPricerPtr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NumericHaganPricer__SWIG_1(void * jarg1, int jarg2, void * jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  Rate arg4 ;
  Rate arg5 ;
  NumericHaganPricerPtr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (Rate)jarg5; 
  {
    try {
      result = (NumericHaganPricerPtr *)new_NumericHaganPricerPtr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NumericHaganPricer__SWIG_2(void * jarg1, int jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  Rate arg4 ;
  NumericHaganPricerPtr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (NumericHaganPricerPtr *)new_NumericHaganPricerPtr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NumericHaganPricer__SWIG_3(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  NumericHaganPricerPtr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (NumericHaganPricerPtr *)new_NumericHaganPricerPtr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NumericHaganPricer(void * jarg1) {
  NumericHaganPricerPtr *arg1 = (NumericHaganPricerPtr *) 0 ;
  
  arg1 = (NumericHaganPricerPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, void * jarg11, void * jarg12, void * jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, void * jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_6(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_7(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  Real arg7 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_8(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  SwapIndexPtr *arg6 = 0 ;
  CappedFlooredCmsCouponPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = (SwapIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsCouponPtr *)new_CappedFlooredCmsCouponPtr__SWIG_0((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(SwapIndexPtr const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CappedFlooredCmsCoupon(void * jarg1) {
  CappedFlooredCmsCouponPtr *arg1 = (CappedFlooredCmsCouponPtr *) 0 ;
  
  arg1 = (CappedFlooredCmsCouponPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearTsrPricer__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  LinearTsrPricer::Settings *arg4 = 0 ;
  LinearTsrPricerPtr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (LinearTsrPricer::Settings *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LinearTsrPricer::Settings const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LinearTsrPricerPtr *)new_LinearTsrPricerPtr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(LinearTsrPricer::Settings const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearTsrPricer__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  LinearTsrPricerPtr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LinearTsrPricerPtr *)new_LinearTsrPricerPtr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearTsrPricer__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  LinearTsrPricerPtr *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LinearTsrPricerPtr *)new_LinearTsrPricerPtr__SWIG_0((Handle< SwaptionVolatilityStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LinearTsrPricer(void * jarg1) {
  LinearTsrPricerPtr *arg1 = (LinearTsrPricerPtr *) 0 ;
  
  arg1 = (LinearTsrPricerPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  bool arg11 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_8(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(IborIndexPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  bool arg11 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_8(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7,(std::vector< double > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6,(std::vector< double > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  SwapIndexPtr *arg3 = 0 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg3 = (SwapIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(SwapIndexPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Leg((const Leg &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Duration() {
  void * jresult ;
  Duration *result = 0 ;
  
  {
    try {
      result = (Duration *)new Duration();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Duration(void * jarg1) {
  Duration *arg1 = (Duration *) 0 ;
  
  arg1 = (Duration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_startDate(void * jarg1) {
  void * jresult ;
  Leg *arg1 = 0 ;
  Date result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = CashFlows::startDate((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_maturityDate(void * jarg1) {
  void * jresult ;
  Leg *arg1 = 0 ;
  Date result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = CashFlows::maturityDate((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,(Date const &)*arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date *arg8 = 0 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_2(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_3(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_4(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_5(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_6(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date arg5 ;
  Date *argp4 ;
  Date *argp5 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (Real)CashFlows::npv((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_7(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date *argp4 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (Real)CashFlows::npv((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_8(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows::npv((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_9(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Date *argp7 ;
  Date *argp8 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (Real)CashFlows::npv((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_10(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Real)CashFlows::npv((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_npv__SWIG_11(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Real)CashFlows::npv((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_3(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_4(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_5(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_6(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date arg5 ;
  Date *argp4 ;
  Date *argp5 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (Real)CashFlows::bps((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_7(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date *argp4 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (Real)CashFlows::bps((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_8(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows::bps((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_9(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Date *argp7 ;
  Date *argp8 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (Real)CashFlows::bps((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_10(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Real)CashFlows::bps((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_bps__SWIG_11(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Real)CashFlows::bps((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_atmRate__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5, double jarg6) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Real arg6 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_atmRate__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_atmRate__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_atmRate__SWIG_3(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_yield__SWIG_0(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, double jarg9, unsigned long jarg10, double jarg11) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Real arg9 ;
  Size arg10 ;
  Rate arg11 ;
  Date *argp7 ;
  Date *argp8 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (Real)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Rate)jarg11; 
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_yield__SWIG_1(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, double jarg9, unsigned long jarg10) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Real arg9 ;
  Size arg10 ;
  Date *argp7 ;
  Date *argp8 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (Real)jarg9; 
  arg10 = (Size)jarg10; 
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_yield__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, double jarg9) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Real arg9 ;
  Date *argp7 ;
  Date *argp8 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_yield__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Date *argp7 ;
  Date *argp8 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_yield__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_yield__SWIG_5(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_duration__SWIG_0(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  bool arg4 ;
  Date arg5 ;
  Date *argp5 ;
  Time result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = (Duration::Type)jarg3; 
  arg4 = jarg4 ? true : false; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (Time)CashFlows::duration((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_duration__SWIG_1(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  bool arg4 ;
  Time result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = (Duration::Type)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Time)CashFlows::duration((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_duration__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Date *argp8 ;
  Date *argp9 ;
  Time result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Duration::Type)jarg6; 
  arg7 = jarg7 ? true : false; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  argp9 = (Date *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg9 = *argp9; 
  {
    try {
      result = (Time)CashFlows::duration((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_duration__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date *argp8 ;
  Time result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Duration::Type)jarg6; 
  arg7 = jarg7 ? true : false; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (Time)CashFlows::duration((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_duration__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, int jarg6, unsigned int jarg7) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  bool arg7 ;
  Time result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Duration::Type)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (Time)CashFlows::duration((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_convexity__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date arg5 ;
  Date *argp4 ;
  Date *argp5 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_convexity__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date *argp4 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_convexity__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_convexity__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Date *argp7 ;
  Date *argp8 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_convexity__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_convexity__SWIG_5(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_basisPointValue__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date arg5 ;
  Date *argp4 ;
  Date *argp5 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_basisPointValue__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date *argp4 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_basisPointValue__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_basisPointValue__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Date *argp7 ;
  Date *argp8 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_basisPointValue__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_basisPointValue__SWIG_5(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
  double jresult ;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_zSpread__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, double jarg10, unsigned long jarg11, double jarg12) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  Size arg11 ;
  Rate arg12 ;
  Date *argp8 ;
  Date *argp9 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  argp9 = (Date *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (Rate)jarg12; 
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_zSpread__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, double jarg10, unsigned long jarg11) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  Size arg11 ;
  Date *argp8 ;
  Date *argp9 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  argp9 = (Date *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_zSpread__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, double jarg10) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  Date *argp8 ;
  Date *argp9 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  argp9 = (Date *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_zSpread__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Date *argp8 ;
  Date *argp9 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  argp9 = (Date *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg9 = *argp9; 
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_zSpread__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7, void * jarg8) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date *argp8 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_zSpread__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned int jarg7) {
  double jresult ;
  Leg *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CashFlows(void * jarg1) {
  CashFlows *arg1 = (CashFlows *) 0 ;
  
  arg1 = (CashFlows *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib__CalibrationHelper_setPricingEngine(void * jarg1, void * jarg2) {
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  boost::shared_ptr< PricingEngine > *arg2 = 0 ;
  
  arg1 = (CalibrationHelper *)jarg1; 
  arg2 = (boost::shared_ptr< PricingEngine > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< PricingEngine > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setPricingEngine((boost::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib__CalibrationHelper_marketValue(void * jarg1) {
  double jresult ;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  Real result;
  
  arg1 = (CalibrationHelper *)jarg1; 
  {
    try {
      result = (Real)((CalibrationHelper const *)arg1)->marketValue();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib__CalibrationHelper_modelValue(void * jarg1) {
  double jresult ;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  Real result;
  
  arg1 = (CalibrationHelper *)jarg1; 
  {
    try {
      result = (Real)((CalibrationHelper const *)arg1)->modelValue();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib__CalibrationHelper_calibrationError(void * jarg1) {
  double jresult ;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  Real result;
  
  arg1 = (CalibrationHelper *)jarg1; 
  {
    try {
      result = (Real)(arg1)->calibrationError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib__CalibrationHelper_impliedVolatility(void * jarg1, double jarg2, double jarg3, unsigned long jarg4, double jarg5, double jarg6) {
  double jresult ;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Size arg4 ;
  Volatility arg5 ;
  Volatility arg6 ;
  Volatility result;
  
  arg1 = (CalibrationHelper *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Volatility)jarg5; 
  arg6 = (Volatility)jarg6; 
  {
    try {
      result = (Volatility)((CalibrationHelper const *)arg1)->impliedVolatility(arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib__CalibrationHelper_blackPrice(void * jarg1, double jarg2) {
  double jresult ;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  Volatility arg2 ;
  Real result;
  
  arg1 = (CalibrationHelper *)jarg1; 
  arg2 = (Volatility)jarg2; 
  {
    try {
      result = (Real)((CalibrationHelper const *)arg1)->blackPrice(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib__CalibrationHelper_volatility(void * jarg1) {
  void * jresult ;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  Handle< Quote > result;
  
  arg1 = (CalibrationHelper *)jarg1; 
  {
    try {
      result = ((CalibrationHelper const *)arg1)->volatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< Quote >((const Handle< Quote > &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib__CalibrationHelper_volatilityType(void * jarg1) {
  int jresult ;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  VolatilityType result;
  
  arg1 = (CalibrationHelper *)jarg1; 
  {
    try {
      result = (VolatilityType)((CalibrationHelper const *)arg1)->volatilityType();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__CalibrationHelper(void * jarg1) {
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  
  arg1 = (CalibrationHelper *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelper___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  CalibrationHelper *result = 0 ;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (CalibrationHelper *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_CalibrationHelper_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_RelativePriceError_get() {
  int jresult ;
  enum CalibrationHelper::CalibrationErrorType result;
  
  result = (enum CalibrationHelper::CalibrationErrorType)CalibrationHelper::RelativePriceError;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_PriceError_get() {
  int jresult ;
  enum CalibrationHelper::CalibrationErrorType result;
  
  result = (enum CalibrationHelper::CalibrationErrorType)CalibrationHelper::PriceError;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_ImpliedVolError_get() {
  int jresult ;
  enum CalibrationHelper::CalibrationErrorType result;
  
  result = (enum CalibrationHelper::CalibrationErrorType)CalibrationHelper::ImpliedVolError;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_swaptionExpiryDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_CalibrationHelper_Sg__swaptionExpiryDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_swaptionStrike(void * jarg1) {
  double jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (Real)boost_shared_ptr_Sl_CalibrationHelper_Sg__swaptionStrike(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_swaptionNominal(void * jarg1) {
  double jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (Real)boost_shared_ptr_Sl_CalibrationHelper_Sg__swaptionNominal(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_swaptionMaturityDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_CalibrationHelper_Sg__swaptionMaturityDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibrationHelper() {
  void * jresult ;
  boost::shared_ptr< CalibrationHelper > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< CalibrationHelper > *)new boost::shared_ptr< CalibrationHelper >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CalibrationHelper(void * jarg1) {
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_setPricingEngine(void * jarg1, void * jarg2) {
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  boost::shared_ptr< PricingEngine > *arg2 = 0 ;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  arg2 = (boost::shared_ptr< PricingEngine > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< PricingEngine > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setPricingEngine((boost::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_marketValue(void * jarg1) {
  double jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->marketValue();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_modelValue(void * jarg1) {
  double jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->modelValue();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_calibrationError(void * jarg1) {
  double jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->calibrationError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_impliedVolatility(void * jarg1, double jarg2, double jarg3, unsigned long jarg4, double jarg5, double jarg6) {
  double jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Size arg4 ;
  Volatility arg5 ;
  Volatility arg6 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Volatility)jarg5; 
  arg6 = (Volatility)jarg6; 
  {
    try {
      result = (Volatility)(*arg1)->impliedVolatility(arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_blackPrice(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Volatility arg2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  arg2 = (Volatility)jarg2; 
  {
    try {
      result = (Real)(*arg1)->blackPrice(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_volatility(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  Handle< Quote > result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (*arg1)->volatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< Quote >((const Handle< Quote > &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CalibrationHelper_volatilityType(void * jarg1) {
  int jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = (boost::shared_ptr< CalibrationHelper > *) 0 ;
  VolatilityType result;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1; 
  {
    try {
      result = (VolatilityType)(*arg1)->volatilityType();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11, int jarg12, double jarg13) {
  void * jresult ;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_0((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11, int jarg12) {
  void * jresult ;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_0((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_0((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10) {
  void * jresult ;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_0((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_0((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_0((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11, int jarg12, double jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_6((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11, int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_6((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_8(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_6((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_9(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_6((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_6((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_6((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11, int jarg12, double jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_12((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_13(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11, int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_12((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_14(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_12((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_15(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_12((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_16(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  CalibrationHelper::CalibrationErrorType arg9 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (CalibrationHelper::CalibrationErrorType)jarg9; 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_12((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionHelper__SWIG_17(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  SwaptionHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionHelperPtr *)new_SwaptionHelperPtr__SWIG_12((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(IborIndexPtr const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionHelper_times(void * jarg1) {
  void * jresult ;
  SwaptionHelperPtr *arg1 = (SwaptionHelperPtr *) 0 ;
  std::vector< Time > result;
  
  arg1 = (SwaptionHelperPtr *)jarg1; 
  {
    try {
      result = SwaptionHelperPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Time >((const std::vector< Time > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionHelper(void * jarg1) {
  SwaptionHelperPtr *arg1 = (SwaptionHelperPtr *) 0 ;
  
  arg1 = (SwaptionHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapHelper__SWIG_0(void * jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5, unsigned int jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  CalibrationHelper::CalibrationErrorType arg8 ;
  CapHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg8 = (CalibrationHelper::CalibrationErrorType)jarg8; 
  {
    try {
      result = (CapHelperPtr *)new_CapHelperPtr__SWIG_0((Period const &)*arg1,(Handle< Quote > const &)*arg2,(IborIndexPtr const &)*arg3,arg4,(DayCounter const &)*arg5,arg6,(Handle< YieldTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapHelper__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5, unsigned int jarg6, void * jarg7) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  CapHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapHelperPtr *)new_CapHelperPtr__SWIG_0((Period const &)*arg1,(Handle< Quote > const &)*arg2,(IborIndexPtr const &)*arg3,arg4,(DayCounter const &)*arg5,arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapHelper_times(void * jarg1) {
  void * jresult ;
  CapHelperPtr *arg1 = (CapHelperPtr *) 0 ;
  std::vector< Time > result;
  
  arg1 = (CapHelperPtr *)jarg1; 
  {
    try {
      result = CapHelperPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Time >((const std::vector< Time > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapHelper(void * jarg1) {
  CapHelperPtr *arg1 = (CapHelperPtr *) 0 ;
  
  arg1 = (CapHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonModelHelper__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Period *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Handle< Quote > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  CalibrationHelper::CalibrationErrorType arg8 ;
  HestonModelHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg8 = (CalibrationHelper::CalibrationErrorType)jarg8; 
  {
    try {
      result = (HestonModelHelperPtr *)new_HestonModelHelperPtr__SWIG_0((Period const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(Handle< Quote > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonModelHelper__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Period *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Handle< Quote > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  HestonModelHelperPtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonModelHelperPtr *)new_HestonModelHelperPtr__SWIG_0((Period const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(Handle< Quote > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonModelHelper(void * jarg1) {
  HestonModelHelperPtr *arg1 = (HestonModelHelperPtr *) 0 ;
  
  arg1 = (HestonModelHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  boost::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< CalibrationHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibrationHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< CalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< CalibrationHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< CalibrationHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibrationHelperVector__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< CalibrationHelper > > *)new std::vector< boost::shared_ptr< CalibrationHelper > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibrationHelperVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< CalibrationHelper > > *)new std::vector< boost::shared_ptr< CalibrationHelper > >((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibrationHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< CalibrationHelper > > *)new_std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< CalibrationHelper > result;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< CalibrationHelper >((const boost::shared_ptr< CalibrationHelper > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< CalibrationHelper > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< CalibrationHelper > *) &std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< CalibrationHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< CalibrationHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibrationHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< CalibrationHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< CalibrationHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< CalibrationHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< CalibrationHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibrationHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< CalibrationHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< CalibrationHelper > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< CalibrationHelper > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibrationHelper > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< CalibrationHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Repeat((boost::shared_ptr< CalibrationHelper > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  boost::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< CalibrationHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibrationHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Contains(arg1,(boost::shared_ptr< CalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  boost::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< CalibrationHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibrationHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< CalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  boost::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< CalibrationHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibrationHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< CalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  boost::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< CalibrationHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibrationHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Remove(arg1,(boost::shared_ptr< CalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CalibrationHelperVector(void * jarg1) {
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibratedModel___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  CalibratedModel *result = 0 ;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  {
    try {
      result = (CalibratedModel *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CalibratedModel_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_CalibratedModel_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibratedModel_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_CalibratedModel_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibratedModel() {
  void * jresult ;
  boost::shared_ptr< CalibratedModel > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< CalibratedModel > *)new boost::shared_ptr< CalibratedModel >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CalibratedModel(void * jarg1) {
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibratedModel_parameters(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  Array result;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  {
    try {
      result = (*arg1)->params();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModel_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModel_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModel_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModel_setParams(void * jarg1, void * jarg2) {
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibratedModel_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< CalibratedModel > *arg1 = (boost::shared_ptr< CalibratedModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibratedModelHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibratedModel > *arg1 = 0 ;
  Handle< CalibratedModel > *result = 0 ;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibratedModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< CalibratedModel > *)new Handle< CalibratedModel >((boost::shared_ptr< CalibratedModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibratedModelHandle__SWIG_1() {
  void * jresult ;
  Handle< CalibratedModel > *result = 0 ;
  
  {
    try {
      result = (Handle< CalibratedModel > *)new Handle< CalibratedModel >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  boost::shared_ptr< CalibratedModel > result;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< CalibratedModel >((const boost::shared_ptr< CalibratedModel > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  bool result;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      result = Handle_Sl_CalibratedModel_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CalibratedModelHandle(void * jarg1) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_parameters(void * jarg1) {
  void * jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  Array result;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      result = (*arg1)->params();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_setParams(void * jarg1, void * jarg2) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  Real result;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableCalibratedModelHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CalibratedModel > *arg1 = 0 ;
  RelinkableHandle< CalibratedModel > *result = 0 ;
  
  arg1 = (boost::shared_ptr< CalibratedModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibratedModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< CalibratedModel > *)new RelinkableHandle< CalibratedModel >((boost::shared_ptr< CalibratedModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableCalibratedModelHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< CalibratedModel > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< CalibratedModel > *)new RelinkableHandle< CalibratedModel >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableCalibratedModelHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< CalibratedModel > *arg1 = (RelinkableHandle< CalibratedModel > *) 0 ;
  boost::shared_ptr< CalibratedModel > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< CalibratedModel > *)jarg1; 
  arg2 = (boost::shared_ptr< CalibratedModel > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CalibratedModel > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< CalibratedModel > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableCalibratedModelHandle(void * jarg1) {
  RelinkableHandle< CalibratedModel > *arg1 = (RelinkableHandle< CalibratedModel > *) 0 ;
  
  arg1 = (RelinkableHandle< CalibratedModel > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TimeGrid__SWIG_0() {
  void * jresult ;
  TimeGrid *result = 0 ;
  
  {
    try {
      result = (TimeGrid *)new TimeGrid();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TimeGrid__SWIG_1(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Time arg1 ;
  Size arg2 ;
  TimeGrid *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TimeGrid *)new TimeGrid(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TimeGrid__SWIG_2(void * jarg1) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  TimeGrid *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TimeGrid *)new_TimeGrid__SWIG_2((std::vector< double > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TimeGrid__SWIG_3(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  Size arg2 ;
  TimeGrid *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TimeGrid *)new_TimeGrid__SWIG_3((std::vector< double > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_TimeGrid_size(void * jarg1) {
  unsigned long jresult ;
  TimeGrid *arg1 = (TimeGrid *) 0 ;
  Size result;
  
  arg1 = (TimeGrid *)jarg1; 
  {
    try {
      result = ((TimeGrid const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TimeGrid(void * jarg1) {
  TimeGrid *arg1 = (TimeGrid *) 0 ;
  
  arg1 = (TimeGrid *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Parameter() {
  void * jresult ;
  Parameter *result = 0 ;
  
  {
    try {
      result = (Parameter *)new Parameter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Parameter_params_(void * jarg1) {
  void * jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  Array *result = 0 ;
  
  arg1 = (Parameter *)jarg1; 
  {
    try {
      result = (Array *) &((Parameter const *)arg1)->params();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Parameter_setParam(void * jarg1, unsigned long jarg2, double jarg3) {
  Parameter *arg1 = (Parameter *) 0 ;
  Size arg2 ;
  Real arg3 ;
  
  arg1 = (Parameter *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->setParam(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Parameter_testParams(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  Array *arg2 = 0 ;
  bool result;
  
  arg1 = (Parameter *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)((Parameter const *)arg1)->testParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Parameter_size(void * jarg1) {
  unsigned long jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  Size result;
  
  arg1 = (Parameter *)jarg1; 
  {
    try {
      result = ((Parameter const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Parameter_call(void * jarg1, double jarg2) {
  double jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (Parameter *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((Parameter const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Parameter_constraint(void * jarg1) {
  void * jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  Constraint *result = 0 ;
  
  arg1 = (Parameter *)jarg1; 
  {
    try {
      result = (Constraint *) &((Parameter const *)arg1)->constraint();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Parameter(void * jarg1) {
  Parameter *arg1 = (Parameter *) 0 ;
  
  arg1 = (Parameter *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantParameter__SWIG_0(void * jarg1) {
  void * jresult ;
  Constraint *arg1 = 0 ;
  ConstantParameter *result = 0 ;
  
  arg1 = (Constraint *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantParameter *)new ConstantParameter((Constraint const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantParameter__SWIG_1(double jarg1, void * jarg2) {
  void * jresult ;
  Real arg1 ;
  Constraint *arg2 = 0 ;
  ConstantParameter *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Constraint *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantParameter *)new ConstantParameter(arg1,(Constraint const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConstantParameter(void * jarg1) {
  ConstantParameter *arg1 = (ConstantParameter *) 0 ;
  
  arg1 = (ConstantParameter *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NullParameter() {
  void * jresult ;
  NullParameter *result = 0 ;
  
  {
    try {
      result = (NullParameter *)new NullParameter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NullParameter(void * jarg1) {
  NullParameter *arg1 = (NullParameter *) 0 ;
  
  arg1 = (NullParameter *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConstantParameter__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  Constraint *arg2 = 0 ;
  PiecewiseConstantParameter *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  arg2 = (Constraint *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConstantParameter *)new PiecewiseConstantParameter((std::vector< Time > const &)*arg1,(Constraint const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConstantParameter__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  PiecewiseConstantParameter *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConstantParameter *)new PiecewiseConstantParameter((std::vector< Time > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseConstantParameter(void * jarg1) {
  PiecewiseConstantParameter *arg1 = (PiecewiseConstantParameter *) 0 ;
  
  arg1 = (PiecewiseConstantParameter *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Option(void * jarg1) {
  Option *arg1 = (Option *) 0 ;
  
  arg1 = (Option *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Barrier() {
  void * jresult ;
  Barrier *result = 0 ;
  
  {
    try {
      result = (Barrier *)new Barrier();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Barrier(void * jarg1) {
  Barrier *arg1 = (Barrier *) 0 ;
  
  arg1 = (Barrier *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DoubleBarrier() {
  void * jresult ;
  DoubleBarrier *result = 0 ;
  
  {
    try {
      result = (DoubleBarrier *)new DoubleBarrier();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DoubleBarrier(void * jarg1) {
  DoubleBarrier *arg1 = (DoubleBarrier *) 0 ;
  
  arg1 = (DoubleBarrier *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Payoff___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Payoff > *arg1 = (boost::shared_ptr< Payoff > *) 0 ;
  Payoff *result = 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1; 
  {
    try {
      result = (Payoff *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Payoff_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Payoff > *arg1 = (boost::shared_ptr< Payoff > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Payoff_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Payoff() {
  void * jresult ;
  boost::shared_ptr< Payoff > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Payoff > *)new boost::shared_ptr< Payoff >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Payoff(void * jarg1) {
  boost::shared_ptr< Payoff > *arg1 = (boost::shared_ptr< Payoff > *) 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Payoff_call(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< Payoff > *arg1 = (boost::shared_ptr< Payoff > *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(*arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VanillaOption(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< Payoff > *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  VanillaOptionPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (VanillaOptionPtr *)new_VanillaOptionPtr((boost::shared_ptr< Payoff > const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_VanillaOption_priceCurve(void * jarg1) {
  void * jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  SampledCurve result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = VanillaOptionPtr_priceCurve(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new SampledCurve((const SampledCurve &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_impliedVolatility__SWIG_0(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5, double jarg6, double jarg7) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  Volatility result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)VanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_impliedVolatility__SWIG_1(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5, double jarg6) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  {
    try {
      result = (Volatility)VanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_impliedVolatility__SWIG_2(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (Volatility)VanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_impliedVolatility__SWIG_3(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Volatility result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)VanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_impliedVolatility__SWIG_4(void * jarg1, double jarg2, void * jarg3) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Volatility result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)VanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_delta(void * jarg1) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaOptionPtr_delta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_gamma(void * jarg1) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaOptionPtr_gamma(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_theta(void * jarg1) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaOptionPtr_theta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_thetaPerDay(void * jarg1) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaOptionPtr_thetaPerDay(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_vega(void * jarg1) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaOptionPtr_vega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_rho(void * jarg1) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaOptionPtr_rho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_dividendRho(void * jarg1) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaOptionPtr_dividendRho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaOption_strikeSensitivity(void * jarg1) {
  double jresult ;
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaOptionPtr_strikeSensitivity(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VanillaOption(void * jarg1) {
  VanillaOptionPtr *arg1 = (VanillaOptionPtr *) 0 ;
  
  arg1 = (VanillaOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuropeanOption(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< Payoff > *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  EuropeanOptionPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuropeanOptionPtr *)new_EuropeanOptionPtr((boost::shared_ptr< Payoff > const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuropeanOption(void * jarg1) {
  EuropeanOptionPtr *arg1 = (EuropeanOptionPtr *) 0 ;
  
  arg1 = (EuropeanOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardVanillaOption(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Date arg2 ;
  boost::shared_ptr< Payoff > *arg3 = 0 ;
  boost::shared_ptr< Exercise > *arg4 = 0 ;
  Date *argp2 ;
  ForwardVanillaOptionPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (boost::shared_ptr< Payoff > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg4 = (boost::shared_ptr< Exercise > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardVanillaOptionPtr *)new_ForwardVanillaOptionPtr(arg1,arg2,(boost::shared_ptr< Payoff > const &)*arg3,(boost::shared_ptr< Exercise > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardVanillaOption(void * jarg1) {
  ForwardVanillaOptionPtr *arg1 = (ForwardVanillaOptionPtr *) 0 ;
  
  arg1 = (ForwardVanillaOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuantoVanillaOption(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< Payoff > *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  QuantoVanillaOptionPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantoVanillaOptionPtr *)new_QuantoVanillaOptionPtr((boost::shared_ptr< Payoff > const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuantoVanillaOption_qvega(void * jarg1) {
  double jresult ;
  QuantoVanillaOptionPtr *arg1 = (QuantoVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (QuantoVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)QuantoVanillaOptionPtr_qvega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuantoVanillaOption_qrho(void * jarg1) {
  double jresult ;
  QuantoVanillaOptionPtr *arg1 = (QuantoVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (QuantoVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)QuantoVanillaOptionPtr_qrho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuantoVanillaOption_qlambda(void * jarg1) {
  double jresult ;
  QuantoVanillaOptionPtr *arg1 = (QuantoVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (QuantoVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)QuantoVanillaOptionPtr_qlambda(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoVanillaOption(void * jarg1) {
  QuantoVanillaOptionPtr *arg1 = (QuantoVanillaOptionPtr *) 0 ;
  
  arg1 = (QuantoVanillaOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuantoForwardVanillaOption(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Date arg2 ;
  boost::shared_ptr< Payoff > *arg3 = 0 ;
  boost::shared_ptr< Exercise > *arg4 = 0 ;
  Date *argp2 ;
  QuantoForwardVanillaOptionPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (boost::shared_ptr< Payoff > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg4 = (boost::shared_ptr< Exercise > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantoForwardVanillaOptionPtr *)new_QuantoForwardVanillaOptionPtr(arg1,arg2,(boost::shared_ptr< Payoff > const &)*arg3,(boost::shared_ptr< Exercise > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoForwardVanillaOption(void * jarg1) {
  QuantoForwardVanillaOptionPtr *arg1 = (QuantoForwardVanillaOptionPtr *) 0 ;
  
  arg1 = (QuantoForwardVanillaOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MultiAssetOption_delta(void * jarg1) {
  double jresult ;
  MultiAssetOptionPtr *arg1 = (MultiAssetOptionPtr *) 0 ;
  Real result;
  
  arg1 = (MultiAssetOptionPtr *)jarg1; 
  {
    try {
      result = (Real)MultiAssetOptionPtr_delta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MultiAssetOption_gamma(void * jarg1) {
  double jresult ;
  MultiAssetOptionPtr *arg1 = (MultiAssetOptionPtr *) 0 ;
  Real result;
  
  arg1 = (MultiAssetOptionPtr *)jarg1; 
  {
    try {
      result = (Real)MultiAssetOptionPtr_gamma(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MultiAssetOption_theta(void * jarg1) {
  double jresult ;
  MultiAssetOptionPtr *arg1 = (MultiAssetOptionPtr *) 0 ;
  Real result;
  
  arg1 = (MultiAssetOptionPtr *)jarg1; 
  {
    try {
      result = (Real)MultiAssetOptionPtr_theta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MultiAssetOption_vega(void * jarg1) {
  double jresult ;
  MultiAssetOptionPtr *arg1 = (MultiAssetOptionPtr *) 0 ;
  Real result;
  
  arg1 = (MultiAssetOptionPtr *)jarg1; 
  {
    try {
      result = (Real)MultiAssetOptionPtr_vega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MultiAssetOption_rho(void * jarg1) {
  double jresult ;
  MultiAssetOptionPtr *arg1 = (MultiAssetOptionPtr *) 0 ;
  Real result;
  
  arg1 = (MultiAssetOptionPtr *)jarg1; 
  {
    try {
      result = (Real)MultiAssetOptionPtr_rho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MultiAssetOption_dividendRho(void * jarg1) {
  double jresult ;
  MultiAssetOptionPtr *arg1 = (MultiAssetOptionPtr *) 0 ;
  Real result;
  
  arg1 = (MultiAssetOptionPtr *)jarg1; 
  {
    try {
      result = (Real)MultiAssetOptionPtr_dividendRho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MultiAssetOption() {
  void * jresult ;
  MultiAssetOptionPtr *result = 0 ;
  
  {
    try {
      result = (MultiAssetOptionPtr *)new MultiAssetOptionPtr();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MultiAssetOption(void * jarg1) {
  MultiAssetOptionPtr *arg1 = (MultiAssetOptionPtr *) 0 ;
  
  arg1 = (MultiAssetOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticEuropeanEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticEuropeanEnginePtr *)new_AnalyticEuropeanEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticEuropeanEngine(void * jarg1) {
  AnalyticEuropeanEnginePtr *arg1 = (AnalyticEuropeanEnginePtr *) 0 ;
  
  arg1 = (AnalyticEuropeanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonModel(void * jarg1) {
  void * jresult ;
  HestonProcessPtr *arg1 = 0 ;
  HestonModelPtr *result = 0 ;
  
  arg1 = (HestonProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HestonProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonModelPtr *)new_HestonModelPtr((HestonProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModel_theta(void * jarg1) {
  double jresult ;
  HestonModelPtr *arg1 = (HestonModelPtr *) 0 ;
  Real result;
  
  arg1 = (HestonModelPtr *)jarg1; 
  {
    try {
      result = (Real)HestonModelPtr_theta((HestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModel_kappa(void * jarg1) {
  double jresult ;
  HestonModelPtr *arg1 = (HestonModelPtr *) 0 ;
  Real result;
  
  arg1 = (HestonModelPtr *)jarg1; 
  {
    try {
      result = (Real)HestonModelPtr_kappa((HestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModel_sigma(void * jarg1) {
  double jresult ;
  HestonModelPtr *arg1 = (HestonModelPtr *) 0 ;
  Real result;
  
  arg1 = (HestonModelPtr *)jarg1; 
  {
    try {
      result = (Real)HestonModelPtr_sigma((HestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModel_rho(void * jarg1) {
  double jresult ;
  HestonModelPtr *arg1 = (HestonModelPtr *) 0 ;
  Real result;
  
  arg1 = (HestonModelPtr *)jarg1; 
  {
    try {
      result = (Real)HestonModelPtr_rho((HestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModel_v0(void * jarg1) {
  double jresult ;
  HestonModelPtr *arg1 = (HestonModelPtr *) 0 ;
  Real result;
  
  arg1 = (HestonModelPtr *)jarg1; 
  {
    try {
      result = (Real)HestonModelPtr_v0((HestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonModel(void * jarg1) {
  HestonModelPtr *arg1 = (HestonModelPtr *) 0 ;
  
  arg1 = (HestonModelPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseTimeDependentHestonModel(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Parameter *arg5 = 0 ;
  Parameter *arg6 = 0 ;
  Parameter *arg7 = 0 ;
  Parameter *arg8 = 0 ;
  TimeGrid *arg9 = 0 ;
  PiecewiseTimeDependentHestonModelPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Parameter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & type is null", 0);
    return 0;
  } 
  arg6 = (Parameter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & type is null", 0);
    return 0;
  } 
  arg7 = (Parameter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & type is null", 0);
    return 0;
  } 
  arg8 = (Parameter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & type is null", 0);
    return 0;
  } 
  arg9 = (TimeGrid *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseTimeDependentHestonModelPtr *)new_PiecewiseTimeDependentHestonModelPtr((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,(Parameter const &)*arg5,(Parameter const &)*arg6,(Parameter const &)*arg7,(Parameter const &)*arg8,(TimeGrid const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_theta(void * jarg1, double jarg2) {
  double jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)PiecewiseTimeDependentHestonModelPtr_theta((PiecewiseTimeDependentHestonModelPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_kappa(void * jarg1, double jarg2) {
  double jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)PiecewiseTimeDependentHestonModelPtr_kappa((PiecewiseTimeDependentHestonModelPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_sigma(void * jarg1, double jarg2) {
  double jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)PiecewiseTimeDependentHestonModelPtr_sigma((PiecewiseTimeDependentHestonModelPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_rho(void * jarg1, double jarg2) {
  double jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)PiecewiseTimeDependentHestonModelPtr_rho((PiecewiseTimeDependentHestonModelPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_v0(void * jarg1) {
  double jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  Real result;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  {
    try {
      result = (Real)PiecewiseTimeDependentHestonModelPtr_v0((PiecewiseTimeDependentHestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_s0(void * jarg1) {
  double jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  Real result;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  {
    try {
      result = (Real)PiecewiseTimeDependentHestonModelPtr_s0((PiecewiseTimeDependentHestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_timeGrid(void * jarg1) {
  void * jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  TimeGrid *result = 0 ;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  {
    try {
      result = (TimeGrid *) &PiecewiseTimeDependentHestonModelPtr_timeGrid((PiecewiseTimeDependentHestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_dividendYield(void * jarg1) {
  void * jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  {
    try {
      result = (Handle< YieldTermStructure > *) &PiecewiseTimeDependentHestonModelPtr_dividendYield((PiecewiseTimeDependentHestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_riskFreeRate(void * jarg1) {
  void * jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  {
    try {
      result = (Handle< YieldTermStructure > *) &PiecewiseTimeDependentHestonModelPtr_riskFreeRate((PiecewiseTimeDependentHestonModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseTimeDependentHestonModel(void * jarg1) {
  PiecewiseTimeDependentHestonModelPtr *arg1 = (PiecewiseTimeDependentHestonModelPtr *) 0 ;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonEngine__SWIG_0(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  HestonModelPtr *arg1 = 0 ;
  Size arg2 ;
  AnalyticHestonEnginePtr *result = 0 ;
  
  arg1 = (HestonModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HestonModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (AnalyticHestonEnginePtr *)new_AnalyticHestonEnginePtr__SWIG_0((HestonModelPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  HestonModelPtr *arg1 = 0 ;
  AnalyticHestonEnginePtr *result = 0 ;
  
  arg1 = (HestonModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HestonModelPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticHestonEnginePtr *)new_AnalyticHestonEnginePtr__SWIG_0((HestonModelPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonEngine__SWIG_2(void * jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  HestonModelPtr *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  AnalyticHestonEnginePtr *result = 0 ;
  
  arg1 = (HestonModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HestonModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (AnalyticHestonEnginePtr *)new_AnalyticHestonEnginePtr__SWIG_2((HestonModelPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticHestonEngine(void * jarg1) {
  AnalyticHestonEnginePtr *arg1 = (AnalyticHestonEnginePtr *) 0 ;
  
  arg1 = (AnalyticHestonEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPTDHestonEngine__SWIG_0(void * jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  AnalyticPTDHestonEnginePtr *result = 0 ;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PiecewiseTimeDependentHestonModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (AnalyticPTDHestonEnginePtr *)new_AnalyticPTDHestonEnginePtr__SWIG_0((PiecewiseTimeDependentHestonModelPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPTDHestonEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = 0 ;
  Size arg2 ;
  AnalyticPTDHestonEnginePtr *result = 0 ;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PiecewiseTimeDependentHestonModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (AnalyticPTDHestonEnginePtr *)new_AnalyticPTDHestonEnginePtr__SWIG_1((PiecewiseTimeDependentHestonModelPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPTDHestonEngine__SWIG_2(void * jarg1) {
  void * jresult ;
  PiecewiseTimeDependentHestonModelPtr *arg1 = 0 ;
  AnalyticPTDHestonEnginePtr *result = 0 ;
  
  arg1 = (PiecewiseTimeDependentHestonModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PiecewiseTimeDependentHestonModelPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticPTDHestonEnginePtr *)new_AnalyticPTDHestonEnginePtr__SWIG_1((PiecewiseTimeDependentHestonModelPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticPTDHestonEngine(void * jarg1) {
  AnalyticPTDHestonEnginePtr *arg1 = (AnalyticPTDHestonEnginePtr *) 0 ;
  
  arg1 = (AnalyticPTDHestonEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BatesModel(void * jarg1) {
  void * jresult ;
  BatesProcessPtr *arg1 = 0 ;
  BatesModelPtr *result = 0 ;
  
  arg1 = (BatesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BatesModelPtr *)new_BatesModelPtr((BatesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BatesModel_nu(void * jarg1) {
  double jresult ;
  BatesModelPtr *arg1 = (BatesModelPtr *) 0 ;
  Real result;
  
  arg1 = (BatesModelPtr *)jarg1; 
  {
    try {
      result = (Real)BatesModelPtr_nu((BatesModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BatesModel_delta(void * jarg1) {
  double jresult ;
  BatesModelPtr *arg1 = (BatesModelPtr *) 0 ;
  Real result;
  
  arg1 = (BatesModelPtr *)jarg1; 
  {
    try {
      result = (Real)BatesModelPtr_delta((BatesModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BatesModel_lambda(void * jarg1) {
  double jresult ;
  BatesModelPtr *arg1 = (BatesModelPtr *) 0 ;
  Real result;
  
  arg1 = (BatesModelPtr *)jarg1; 
  {
    try {
      result = (Real)BatesModelPtr_lambda((BatesModelPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BatesModel(void * jarg1) {
  BatesModelPtr *arg1 = (BatesModelPtr *) 0 ;
  
  arg1 = (BatesModelPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BatesEngine__SWIG_0(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  BatesModelPtr *arg1 = 0 ;
  Size arg2 ;
  BatesEnginePtr *result = 0 ;
  
  arg1 = (BatesModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BatesEnginePtr *)new_BatesEnginePtr__SWIG_0((BatesModelPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BatesEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  BatesModelPtr *arg1 = 0 ;
  BatesEnginePtr *result = 0 ;
  
  arg1 = (BatesModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesModelPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BatesEnginePtr *)new_BatesEnginePtr__SWIG_0((BatesModelPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BatesEngine__SWIG_2(void * jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  BatesModelPtr *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  BatesEnginePtr *result = 0 ;
  
  arg1 = (BatesModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BatesEnginePtr *)new_BatesEnginePtr__SWIG_2((BatesModelPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BatesEngine(void * jarg1) {
  BatesEnginePtr *arg1 = (BatesEnginePtr *) 0 ;
  
  arg1 = (BatesEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntegralEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  IntegralEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (IntegralEnginePtr *)new_IntegralEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IntegralEngine(void * jarg1) {
  IntegralEnginePtr *arg1 = (IntegralEnginePtr *) 0 ;
  
  arg1 = (IntegralEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDBermudanEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  FDBermudanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (FDBermudanEnginePtr *)new_FDBermudanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDBermudanEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FDBermudanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FDBermudanEnginePtr *)new_FDBermudanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDBermudanEngine__SWIG_2(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  FDBermudanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FDBermudanEnginePtr *)new_FDBermudanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDBermudanEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  FDBermudanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FDBermudanEnginePtr *)new_FDBermudanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FDBermudanEngine(void * jarg1) {
  FDBermudanEnginePtr *arg1 = (FDBermudanEnginePtr *) 0 ;
  
  arg1 = (FDBermudanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDEuropeanEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  FDEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (FDEuropeanEnginePtr *)new_FDEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDEuropeanEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FDEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FDEuropeanEnginePtr *)new_FDEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDEuropeanEngine__SWIG_2(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  FDEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FDEuropeanEnginePtr *)new_FDEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDEuropeanEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  FDEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FDEuropeanEnginePtr *)new_FDEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FDEuropeanEngine(void * jarg1) {
  FDEuropeanEnginePtr *arg1 = (FDEuropeanEnginePtr *) 0 ;
  
  arg1 = (FDEuropeanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialVanillaEngine(void * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  BinomialVanillaEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialVanillaEnginePtr *)new_BinomialVanillaEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialVanillaEngine(void * jarg1) {
  BinomialVanillaEnginePtr *arg1 = (BinomialVanillaEnginePtr *) 0 ;
  
  arg1 = (BinomialVanillaEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9, long jarg10) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  intOrNull arg3 ;
  intOrNull arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  BigInteger arg10 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (intOrNull)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  arg10 = (BigInteger)jarg10; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_1(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  intOrNull arg3 ;
  intOrNull arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (intOrNull)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_2(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  intOrNull arg3 ;
  intOrNull arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (intOrNull)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_3(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  intOrNull arg3 ;
  intOrNull arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (intOrNull)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_4(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5, unsigned int jarg6) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  intOrNull arg3 ;
  intOrNull arg4 ;
  bool arg5 ;
  bool arg6 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (intOrNull)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_5(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  intOrNull arg3 ;
  intOrNull arg4 ;
  bool arg5 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (intOrNull)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_6(void * jarg1, char * jarg2, int jarg3, int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  intOrNull arg3 ;
  intOrNull arg4 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_7(void * jarg1, char * jarg2, int jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  intOrNull arg3 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanEngine__SWIG_8(void * jarg1, char * jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCEuropeanEnginePtr *)new_MCEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCEuropeanEngine(void * jarg1) {
  MCEuropeanEnginePtr *arg1 = (MCEuropeanEnginePtr *) 0 ;
  
  arg1 = (MCEuropeanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDAmericanEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  FDAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (FDAmericanEnginePtr *)new_FDAmericanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDAmericanEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FDAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FDAmericanEnginePtr *)new_FDAmericanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDAmericanEngine__SWIG_2(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  FDAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FDAmericanEnginePtr *)new_FDAmericanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDAmericanEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  FDAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FDAmericanEnginePtr *)new_FDAmericanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FDAmericanEngine(void * jarg1) {
  FDAmericanEnginePtr *arg1 = (FDAmericanEnginePtr *) 0 ;
  
  arg1 = (FDAmericanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdBlackScholesVanillaEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesVanillaEnginePtr *)new_FdBlackScholesVanillaEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FdBlackScholesVanillaEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesVanillaEnginePtr *)new_FdBlackScholesVanillaEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_2(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  FdBlackScholesVanillaEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdBlackScholesVanillaEnginePtr *)new_FdBlackScholesVanillaEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  FdBlackScholesVanillaEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesVanillaEnginePtr *)new_FdBlackScholesVanillaEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBlackScholesVanillaEngine(void * jarg1) {
  FdBlackScholesVanillaEnginePtr *arg1 = (FdBlackScholesVanillaEnginePtr *) 0 ;
  
  arg1 = (FdBlackScholesVanillaEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  BatesModelPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdBatesVanillaEnginePtr *result = 0 ;
  
  arg1 = (BatesModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBatesVanillaEnginePtr *)new_FdBatesVanillaEnginePtr__SWIG_0((BatesModelPtr const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  BatesModelPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdBatesVanillaEnginePtr *result = 0 ;
  
  arg1 = (BatesModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBatesVanillaEnginePtr *)new_FdBatesVanillaEnginePtr__SWIG_0((BatesModelPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  BatesModelPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FdBatesVanillaEnginePtr *result = 0 ;
  
  arg1 = (BatesModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBatesVanillaEnginePtr *)new_FdBatesVanillaEnginePtr__SWIG_0((BatesModelPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_3(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  BatesModelPtr *arg1 = 0 ;
  Size arg2 ;
  FdBatesVanillaEnginePtr *result = 0 ;
  
  arg1 = (BatesModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesModelPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdBatesVanillaEnginePtr *)new_FdBatesVanillaEnginePtr__SWIG_0((BatesModelPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_4(void * jarg1) {
  void * jresult ;
  BatesModelPtr *arg1 = 0 ;
  FdBatesVanillaEnginePtr *result = 0 ;
  
  arg1 = (BatesModelPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BatesModelPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBatesVanillaEnginePtr *)new_FdBatesVanillaEnginePtr__SWIG_0((BatesModelPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBatesVanillaEngine(void * jarg1) {
  FdBatesVanillaEnginePtr *arg1 = (FdBatesVanillaEnginePtr *) 0 ;
  
  arg1 = (FdBatesVanillaEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ContinuousArithmeticAsianLevyEngine(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Date *arg3 = 0 ;
  ContinuousArithmeticAsianLevyEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ContinuousArithmeticAsianLevyEnginePtr *)new_ContinuousArithmeticAsianLevyEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1,(Handle< Quote > const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ContinuousArithmeticAsianLevyEngine(void * jarg1) {
  ContinuousArithmeticAsianLevyEnginePtr *arg1 = (ContinuousArithmeticAsianLevyEnginePtr *) 0 ;
  
  arg1 = (ContinuousArithmeticAsianLevyEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesAsianEngine(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdBlackScholesAsianEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesAsianEnginePtr *)new_FdBlackScholesAsianEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBlackScholesAsianEngine(void * jarg1) {
  FdBlackScholesAsianEnginePtr *arg1 = (FdBlackScholesAsianEnginePtr *) 0 ;
  
  arg1 = (FdBlackScholesAsianEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDShoutEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  FDShoutEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (FDShoutEnginePtr *)new_FDShoutEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDShoutEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FDShoutEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FDShoutEnginePtr *)new_FDShoutEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDShoutEngine__SWIG_2(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  FDShoutEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FDShoutEnginePtr *)new_FDShoutEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDShoutEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  FDShoutEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FDShoutEnginePtr *)new_FDShoutEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FDShoutEngine(void * jarg1) {
  FDShoutEnginePtr *arg1 = (FDShoutEnginePtr *) 0 ;
  
  arg1 = (FDShoutEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BaroneAdesiWhaleyEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  BaroneAdesiWhaleyApproximationEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BaroneAdesiWhaleyApproximationEnginePtr *)new_BaroneAdesiWhaleyApproximationEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BaroneAdesiWhaleyEngine(void * jarg1) {
  BaroneAdesiWhaleyApproximationEnginePtr *arg1 = (BaroneAdesiWhaleyApproximationEnginePtr *) 0 ;
  
  arg1 = (BaroneAdesiWhaleyApproximationEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BjerksundStenslandEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  BjerksundStenslandApproximationEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BjerksundStenslandApproximationEnginePtr *)new_BjerksundStenslandApproximationEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BjerksundStenslandEngine(void * jarg1) {
  BjerksundStenslandApproximationEnginePtr *arg1 = (BjerksundStenslandApproximationEnginePtr *) 0 ;
  
  arg1 = (BjerksundStenslandApproximationEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDigitalAmericanEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticDigitalAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticDigitalAmericanEnginePtr *)new_AnalyticDigitalAmericanEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDigitalAmericanEngine(void * jarg1) {
  AnalyticDigitalAmericanEnginePtr *arg1 = (AnalyticDigitalAmericanEnginePtr *) 0 ;
  
  arg1 = (AnalyticDigitalAmericanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDigitalAmericanKOEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticDigitalAmericanKOEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticDigitalAmericanKOEnginePtr *)new_AnalyticDigitalAmericanKOEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDigitalAmericanKOEngine(void * jarg1) {
  AnalyticDigitalAmericanKOEnginePtr *arg1 = (AnalyticDigitalAmericanKOEnginePtr *) 0 ;
  
  arg1 = (AnalyticDigitalAmericanKOEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DividendVanillaOption(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  boost::shared_ptr< Payoff > *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  DividendVanillaOptionPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DividendVanillaOptionPtr *)new_DividendVanillaOptionPtr((boost::shared_ptr< Payoff > const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_priceCurve(void * jarg1) {
  void * jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  SampledCurve result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = DividendVanillaOptionPtr_priceCurve(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new SampledCurve((const SampledCurve &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_impliedVolatility__SWIG_0(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5, double jarg6, double jarg7) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  Volatility result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)DividendVanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_impliedVolatility__SWIG_1(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5, double jarg6) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  {
    try {
      result = (Volatility)DividendVanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_impliedVolatility__SWIG_2(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (Volatility)DividendVanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_impliedVolatility__SWIG_3(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Volatility result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)DividendVanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_impliedVolatility__SWIG_4(void * jarg1, double jarg2, void * jarg3) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Volatility result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)DividendVanillaOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_delta(void * jarg1) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DividendVanillaOptionPtr_delta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_gamma(void * jarg1) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DividendVanillaOptionPtr_gamma(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_theta(void * jarg1) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DividendVanillaOptionPtr_theta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_thetaPerDay(void * jarg1) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DividendVanillaOptionPtr_thetaPerDay(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_vega(void * jarg1) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DividendVanillaOptionPtr_vega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_rho(void * jarg1) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DividendVanillaOptionPtr_rho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_dividendRho(void * jarg1) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DividendVanillaOptionPtr_dividendRho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_strikeSensitivity(void * jarg1) {
  double jresult ;
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DividendVanillaOptionPtr_strikeSensitivity(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DividendVanillaOption(void * jarg1) {
  DividendVanillaOptionPtr *arg1 = (DividendVanillaOptionPtr *) 0 ;
  
  arg1 = (DividendVanillaOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDividendEuropeanEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticDividendEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticDividendEuropeanEnginePtr *)new_AnalyticDividendEuropeanEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDividendEuropeanEngine(void * jarg1) {
  AnalyticDividendEuropeanEnginePtr *arg1 = (AnalyticDividendEuropeanEnginePtr *) 0 ;
  
  arg1 = (AnalyticDividendEuropeanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDDividendEuropeanEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  FDDividendEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (FDDividendEuropeanEnginePtr *)new_FDDividendEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDDividendEuropeanEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FDDividendEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FDDividendEuropeanEnginePtr *)new_FDDividendEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDDividendEuropeanEngine__SWIG_2(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  FDDividendEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FDDividendEuropeanEnginePtr *)new_FDDividendEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDDividendEuropeanEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  FDDividendEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FDDividendEuropeanEnginePtr *)new_FDDividendEuropeanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FDDividendEuropeanEngine(void * jarg1) {
  FDDividendEuropeanEnginePtr *arg1 = (FDDividendEuropeanEnginePtr *) 0 ;
  
  arg1 = (FDDividendEuropeanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDDividendAmericanEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  FDDividendAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (FDDividendAmericanEnginePtr *)new_FDDividendAmericanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDDividendAmericanEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FDDividendAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FDDividendAmericanEnginePtr *)new_FDDividendAmericanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDDividendAmericanEngine__SWIG_2(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  FDDividendAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FDDividendAmericanEnginePtr *)new_FDDividendAmericanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FDDividendAmericanEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  FDDividendAmericanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FDDividendAmericanEnginePtr *)new_FDDividendAmericanEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FDDividendAmericanEngine(void * jarg1) {
  FDDividendAmericanEnginePtr *arg1 = (FDDividendAmericanEnginePtr *) 0 ;
  
  arg1 = (FDDividendAmericanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BarrierOption(int jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Barrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  boost::shared_ptr< Payoff > *arg4 = 0 ;
  boost::shared_ptr< Exercise > *arg5 = 0 ;
  BarrierOptionPtr *result = 0 ;
  
  arg1 = (Barrier::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (boost::shared_ptr< Payoff > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg5 = (boost::shared_ptr< Exercise > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BarrierOptionPtr *)new_BarrierOptionPtr(arg1,arg2,arg3,(boost::shared_ptr< Payoff > const &)*arg4,(boost::shared_ptr< Exercise > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BarrierOption_priceCurve(void * jarg1) {
  void * jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  SampledCurve result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = BarrierOptionPtr_priceCurve(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new SampledCurve((const SampledCurve &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_impliedVolatility__SWIG_0(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5, double jarg6, double jarg7) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  Volatility result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)BarrierOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_impliedVolatility__SWIG_1(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5, double jarg6) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  {
    try {
      result = (Volatility)BarrierOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_impliedVolatility__SWIG_2(void * jarg1, double jarg2, void * jarg3, double jarg4, unsigned long jarg5) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (Volatility)BarrierOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_impliedVolatility__SWIG_3(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Real arg4 ;
  Volatility result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)BarrierOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_impliedVolatility__SWIG_4(void * jarg1, double jarg2, void * jarg3) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real arg2 ;
  GeneralizedBlackScholesProcessPtr *arg3 = 0 ;
  Volatility result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (GeneralizedBlackScholesProcessPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)BarrierOptionPtr_impliedVolatility__SWIG_0(arg1,arg2,(GeneralizedBlackScholesProcessPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_delta(void * jarg1) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)BarrierOptionPtr_delta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_gamma(void * jarg1) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)BarrierOptionPtr_gamma(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_theta(void * jarg1) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)BarrierOptionPtr_theta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_thetaPerDay(void * jarg1) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)BarrierOptionPtr_thetaPerDay(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_vega(void * jarg1) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)BarrierOptionPtr_vega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_rho(void * jarg1) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)BarrierOptionPtr_rho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_dividendRho(void * jarg1) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)BarrierOptionPtr_dividendRho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BarrierOption_strikeSensitivity(void * jarg1) {
  double jresult ;
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)BarrierOptionPtr_strikeSensitivity(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BarrierOption(void * jarg1) {
  BarrierOptionPtr *arg1 = (BarrierOptionPtr *) 0 ;
  
  arg1 = (BarrierOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticBarrierEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticBarrierEnginePtr *)new_AnalyticBarrierEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticBarrierEngine(void * jarg1) {
  AnalyticBarrierEnginePtr *arg1 = (AnalyticBarrierEnginePtr *) 0 ;
  
  arg1 = (AnalyticBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_0(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9, unsigned int jarg10, long jarg11) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  bool arg10 ;
  BigInteger arg11 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  arg10 = jarg10 ? true : false; 
  arg11 = (BigInteger)jarg11; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_1(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9, unsigned int jarg10) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  bool arg10 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  arg10 = jarg10 ? true : false; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_2(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_3(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_4(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_5(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_6(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_7(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_8(void * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCBarrierEngine__SWIG_9(void * jarg1, char * jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCBarrierEnginePtr *)new_MCBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCBarrierEngine(void * jarg1) {
  MCBarrierEnginePtr *arg1 = (MCBarrierEnginePtr *) 0 ;
  
  arg1 = (MCBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSchemeDesc(int jarg1, double jarg2, double jarg3) {
  void * jresult ;
  FdmSchemeDesc::FdmSchemeType arg1 ;
  Real arg2 ;
  Real arg3 ;
  FdmSchemeDesc *result = 0 ;
  
  arg1 = (FdmSchemeDesc::FdmSchemeType)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (FdmSchemeDesc *)new FdmSchemeDesc(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_type_get(void * jarg1) {
  int jresult ;
  FdmSchemeDesc *arg1 = (FdmSchemeDesc *) 0 ;
  FdmSchemeDesc::FdmSchemeType result;
  
  arg1 = (FdmSchemeDesc *)jarg1; 
  result = (FdmSchemeDesc::FdmSchemeType)(FdmSchemeDesc::FdmSchemeType) ((arg1)->type);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_theta_get(void * jarg1) {
  double jresult ;
  FdmSchemeDesc *arg1 = (FdmSchemeDesc *) 0 ;
  Real result;
  
  arg1 = (FdmSchemeDesc *)jarg1; 
  result = (Real)(Real) ((arg1)->theta);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_mu_get(void * jarg1) {
  double jresult ;
  FdmSchemeDesc *arg1 = (FdmSchemeDesc *) 0 ;
  Real result;
  
  arg1 = (FdmSchemeDesc *)jarg1; 
  result = (Real)(Real) ((arg1)->mu);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_Douglas() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::Douglas();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmSchemeDesc((const FdmSchemeDesc &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_ImplicitEuler() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::ImplicitEuler();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmSchemeDesc((const FdmSchemeDesc &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_ExplicitEuler() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::ExplicitEuler();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmSchemeDesc((const FdmSchemeDesc &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_CraigSneyd() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::CraigSneyd();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmSchemeDesc((const FdmSchemeDesc &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_ModifiedCraigSneyd() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::ModifiedCraigSneyd();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmSchemeDesc((const FdmSchemeDesc &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_Hundsdorfer() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::Hundsdorfer();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmSchemeDesc((const FdmSchemeDesc &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_ModifiedHundsdorfer() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::ModifiedHundsdorfer();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmSchemeDesc((const FdmSchemeDesc &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmSchemeDesc(void * jarg1) {
  FdmSchemeDesc *arg1 = (FdmSchemeDesc *) 0 ;
  
  arg1 = (FdmSchemeDesc *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5, unsigned int jarg6, double jarg7) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  FdBlackScholesBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FdBlackScholesBarrierEnginePtr *)new_FdBlackScholesBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  FdBlackScholesBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (FdBlackScholesBarrierEnginePtr *)new_FdBlackScholesBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  FdBlackScholesBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesBarrierEnginePtr *)new_FdBlackScholesBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdBlackScholesBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesBarrierEnginePtr *)new_FdBlackScholesBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FdBlackScholesBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesBarrierEnginePtr *)new_FdBlackScholesBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_5(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Size arg2 ;
  FdBlackScholesBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdBlackScholesBarrierEnginePtr *)new_FdBlackScholesBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  FdBlackScholesBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesBarrierEnginePtr *)new_FdBlackScholesBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBlackScholesBarrierEngine(void * jarg1) {
  FdBlackScholesBarrierEnginePtr *arg1 = (FdBlackScholesBarrierEnginePtr *) 0 ;
  
  arg1 = (FdBlackScholesBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticBinaryBarrierEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticBinaryBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticBinaryBarrierEnginePtr *)new_AnalyticBinaryBarrierEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticBinaryBarrierEngine(void * jarg1) {
  AnalyticBinaryBarrierEnginePtr *arg1 = (AnalyticBinaryBarrierEnginePtr *) 0 ;
  
  arg1 = (AnalyticBinaryBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialBarrierEngine__SWIG_0(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  BinomialBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (BinomialBarrierEnginePtr *)new_BinomialBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialBarrierEngine__SWIG_1(void * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  BinomialBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialBarrierEnginePtr *)new_BinomialBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialBarrierEngine(void * jarg1) {
  BinomialBarrierEnginePtr *arg1 = (BinomialBarrierEnginePtr *) 0 ;
  
  arg1 = (BinomialBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardEuropeanEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  ForwardEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardEuropeanEnginePtr *)new_ForwardEuropeanEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardEuropeanEngine(void * jarg1) {
  ForwardEuropeanEnginePtr *arg1 = (ForwardEuropeanEnginePtr *) 0 ;
  
  arg1 = (ForwardEuropeanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuantoEuropeanEngine(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  QuantoEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< BlackVolTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantoEuropeanEnginePtr *)new_QuantoEuropeanEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< BlackVolTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoEuropeanEngine(void * jarg1) {
  QuantoEuropeanEnginePtr *arg1 = (QuantoEuropeanEnginePtr *) 0 ;
  
  arg1 = (QuantoEuropeanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuantoForwardEuropeanEngine(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  QuantoForwardEuropeanEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< BlackVolTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantoForwardEuropeanEnginePtr *)new_QuantoForwardEuropeanEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< BlackVolTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoForwardEuropeanEngine(void * jarg1) {
  QuantoForwardEuropeanEnginePtr *arg1 = (QuantoForwardEuropeanEnginePtr *) 0 ;
  
  arg1 = (QuantoForwardEuropeanEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCalculator__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  boost::shared_ptr< Payoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  BlackCalculator *result = 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (BlackCalculator *)new_BlackCalculator__SWIG_0((boost::shared_ptr< Payoff > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCalculator__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  boost::shared_ptr< Payoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  BlackCalculator *result = 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (BlackCalculator *)new_BlackCalculator__SWIG_0((boost::shared_ptr< Payoff > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_value(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->value();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_deltaForward(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->deltaForward();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_delta(void * jarg1, double jarg2) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->delta(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_elasticityForward(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->elasticityForward();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_elasticity(void * jarg1, double jarg2) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->elasticity(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_gammaForward(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->gammaForward();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_gamma(void * jarg1, double jarg2) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->gamma(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_theta(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->theta(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_thetaPerDay(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->thetaPerDay(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_vega(void * jarg1, double jarg2) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->vega(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_rho(void * jarg1, double jarg2) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->rho(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_dividendRho(void * jarg1, double jarg2) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->dividendRho(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_itmCashProbability(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->itmCashProbability();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_itmAssetProbability(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->itmAssetProbability();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_strikeSensitivity(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->strikeSensitivity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_alpha(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackCalculator_beta(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackCalculator(void * jarg1) {
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Average() {
  void * jresult ;
  Average *result = 0 ;
  
  {
    try {
      result = (Average *)new Average();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Average(void * jarg1) {
  Average *arg1 = (Average *) 0 ;
  
  arg1 = (Average *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ContinuousAveragingAsianOption(int jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Average::Type arg1 ;
  boost::shared_ptr< Payoff > *arg2 = 0 ;
  boost::shared_ptr< Exercise > *arg3 = 0 ;
  ContinuousAveragingAsianOptionPtr *result = 0 ;
  
  arg1 = (Average::Type)jarg1; 
  arg2 = (boost::shared_ptr< Payoff > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg3 = (boost::shared_ptr< Exercise > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ContinuousAveragingAsianOptionPtr *)new_ContinuousAveragingAsianOptionPtr(arg1,(boost::shared_ptr< Payoff > const &)*arg2,(boost::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_delta(void * jarg1) {
  double jresult ;
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)ContinuousAveragingAsianOptionPtr_delta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_gamma(void * jarg1) {
  double jresult ;
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)ContinuousAveragingAsianOptionPtr_gamma(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_theta(void * jarg1) {
  double jresult ;
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)ContinuousAveragingAsianOptionPtr_theta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_thetaPerDay(void * jarg1) {
  double jresult ;
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)ContinuousAveragingAsianOptionPtr_thetaPerDay(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_vega(void * jarg1) {
  double jresult ;
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)ContinuousAveragingAsianOptionPtr_vega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_rho(void * jarg1) {
  double jresult ;
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)ContinuousAveragingAsianOptionPtr_rho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_dividendRho(void * jarg1) {
  double jresult ;
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)ContinuousAveragingAsianOptionPtr_dividendRho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_strikeSensitivity(void * jarg1) {
  double jresult ;
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)ContinuousAveragingAsianOptionPtr_strikeSensitivity(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ContinuousAveragingAsianOption(void * jarg1) {
  ContinuousAveragingAsianOptionPtr *arg1 = (ContinuousAveragingAsianOptionPtr *) 0 ;
  
  arg1 = (ContinuousAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscreteAveragingAsianOption(int jarg1, double jarg2, unsigned long jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Average::Type arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::vector< Date > *arg4 = 0 ;
  boost::shared_ptr< Payoff > *arg5 = 0 ;
  boost::shared_ptr< Exercise > *arg6 = 0 ;
  DiscreteAveragingAsianOptionPtr *result = 0 ;
  
  arg1 = (Average::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (std::vector< Date > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg5 = (boost::shared_ptr< Payoff > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg6 = (boost::shared_ptr< Exercise > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscreteAveragingAsianOptionPtr *)new_DiscreteAveragingAsianOptionPtr(arg1,arg2,arg3,(std::vector< Date > const &)*arg4,(boost::shared_ptr< Payoff > const &)*arg5,(boost::shared_ptr< Exercise > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_delta(void * jarg1) {
  double jresult ;
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DiscreteAveragingAsianOptionPtr_delta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_gamma(void * jarg1) {
  double jresult ;
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DiscreteAveragingAsianOptionPtr_gamma(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_theta(void * jarg1) {
  double jresult ;
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DiscreteAveragingAsianOptionPtr_theta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_thetaPerDay(void * jarg1) {
  double jresult ;
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DiscreteAveragingAsianOptionPtr_thetaPerDay(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_vega(void * jarg1) {
  double jresult ;
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DiscreteAveragingAsianOptionPtr_vega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_rho(void * jarg1) {
  double jresult ;
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DiscreteAveragingAsianOptionPtr_rho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_dividendRho(void * jarg1) {
  double jresult ;
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DiscreteAveragingAsianOptionPtr_dividendRho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_strikeSensitivity(void * jarg1) {
  double jresult ;
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DiscreteAveragingAsianOptionPtr_strikeSensitivity(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DiscreteAveragingAsianOption(void * jarg1) {
  DiscreteAveragingAsianOptionPtr *arg1 = (DiscreteAveragingAsianOptionPtr *) 0 ;
  
  arg1 = (DiscreteAveragingAsianOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticContinuousGeometricAveragePriceAsianEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticContinuousGeometricAveragePriceAsianEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianEnginePtr *)new_AnalyticContinuousGeometricAveragePriceAsianEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticContinuousGeometricAveragePriceAsianEngine(void * jarg1) {
  AnalyticContinuousGeometricAveragePriceAsianEnginePtr *arg1 = (AnalyticContinuousGeometricAveragePriceAsianEnginePtr *) 0 ;
  
  arg1 = (AnalyticContinuousGeometricAveragePriceAsianEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDiscreteGeometricAveragePriceAsianEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticDiscreteGeometricAveragePriceAsianEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticDiscreteGeometricAveragePriceAsianEnginePtr *)new_AnalyticDiscreteGeometricAveragePriceAsianEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDiscreteGeometricAveragePriceAsianEngine(void * jarg1) {
  AnalyticDiscreteGeometricAveragePriceAsianEnginePtr *arg1 = (AnalyticDiscreteGeometricAveragePriceAsianEnginePtr *) 0 ;
  
  arg1 = (AnalyticDiscreteGeometricAveragePriceAsianEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDiscreteGeometricAverageStrikeAsianEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr *)new_AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine(void * jarg1) {
  AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr *arg1 = (AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr *) 0 ;
  
  arg1 = (AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticAPEngine__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  MCDiscreteArithmeticAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCDiscreteArithmeticAPEnginePtr *)new_MCDiscreteArithmeticAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticAPEngine__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  MCDiscreteArithmeticAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCDiscreteArithmeticAPEnginePtr *)new_MCDiscreteArithmeticAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticAPEngine__SWIG_2(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  MCDiscreteArithmeticAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteArithmeticAPEnginePtr *)new_MCDiscreteArithmeticAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticAPEngine__SWIG_3(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  MCDiscreteArithmeticAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteArithmeticAPEnginePtr *)new_MCDiscreteArithmeticAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticAPEngine__SWIG_4(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  MCDiscreteArithmeticAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEnginePtr *)new_MCDiscreteArithmeticAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticAPEngine__SWIG_5(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  MCDiscreteArithmeticAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEnginePtr *)new_MCDiscreteArithmeticAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticAPEngine__SWIG_6(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  MCDiscreteArithmeticAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEnginePtr *)new_MCDiscreteArithmeticAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticAPEngine__SWIG_7(void * jarg1, char * jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCDiscreteArithmeticAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCDiscreteArithmeticAPEnginePtr *)new_MCDiscreteArithmeticAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCDiscreteArithmeticAPEngine(void * jarg1) {
  MCDiscreteArithmeticAPEnginePtr *arg1 = (MCDiscreteArithmeticAPEnginePtr *) 0 ;
  
  arg1 = (MCDiscreteArithmeticAPEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticASEngine__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  MCDiscreteArithmeticASEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCDiscreteArithmeticASEnginePtr *)new_MCDiscreteArithmeticASEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticASEngine__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  MCDiscreteArithmeticASEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteArithmeticASEnginePtr *)new_MCDiscreteArithmeticASEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticASEngine__SWIG_2(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  MCDiscreteArithmeticASEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteArithmeticASEnginePtr *)new_MCDiscreteArithmeticASEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticASEngine__SWIG_3(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  MCDiscreteArithmeticASEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteArithmeticASEnginePtr *)new_MCDiscreteArithmeticASEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticASEngine__SWIG_4(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  MCDiscreteArithmeticASEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticASEnginePtr *)new_MCDiscreteArithmeticASEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticASEngine__SWIG_5(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  MCDiscreteArithmeticASEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticASEnginePtr *)new_MCDiscreteArithmeticASEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteArithmeticASEngine__SWIG_6(void * jarg1, char * jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCDiscreteArithmeticASEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCDiscreteArithmeticASEnginePtr *)new_MCDiscreteArithmeticASEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCDiscreteArithmeticASEngine(void * jarg1) {
  MCDiscreteArithmeticASEnginePtr *arg1 = (MCDiscreteArithmeticASEnginePtr *) 0 ;
  
  arg1 = (MCDiscreteArithmeticASEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteGeometricAPEngine__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  MCDiscreteGeometricAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCDiscreteGeometricAPEnginePtr *)new_MCDiscreteGeometricAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteGeometricAPEngine__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  MCDiscreteGeometricAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteGeometricAPEnginePtr *)new_MCDiscreteGeometricAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteGeometricAPEngine__SWIG_2(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  MCDiscreteGeometricAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteGeometricAPEnginePtr *)new_MCDiscreteGeometricAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteGeometricAPEngine__SWIG_3(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  MCDiscreteGeometricAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteGeometricAPEnginePtr *)new_MCDiscreteGeometricAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteGeometricAPEngine__SWIG_4(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  MCDiscreteGeometricAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCDiscreteGeometricAPEnginePtr *)new_MCDiscreteGeometricAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteGeometricAPEngine__SWIG_5(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  MCDiscreteGeometricAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteGeometricAPEnginePtr *)new_MCDiscreteGeometricAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCDiscreteGeometricAPEngine__SWIG_6(void * jarg1, char * jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCDiscreteGeometricAPEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCDiscreteGeometricAPEnginePtr *)new_MCDiscreteGeometricAPEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCDiscreteGeometricAPEngine(void * jarg1) {
  MCDiscreteGeometricAPEnginePtr *arg1 = (MCDiscreteGeometricAPEnginePtr *) 0 ;
  
  arg1 = (MCDiscreteGeometricAPEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VarianceGammaEngine(void * jarg1) {
  void * jresult ;
  VarianceGammaProcessPtr *arg1 = 0 ;
  VarianceGammaEnginePtr *result = 0 ;
  
  arg1 = (VarianceGammaProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "VarianceGammaProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (VarianceGammaEnginePtr *)new_VarianceGammaEnginePtr((VarianceGammaProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VarianceGammaEngine(void * jarg1) {
  VarianceGammaEnginePtr *arg1 = (VarianceGammaEnginePtr *) 0 ;
  
  arg1 = (VarianceGammaEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FFTVarianceGammaEngine__SWIG_0(void * jarg1, double jarg2) {
  void * jresult ;
  VarianceGammaProcessPtr *arg1 = 0 ;
  Real arg2 ;
  FFTVarianceGammaEnginePtr *result = 0 ;
  
  arg1 = (VarianceGammaProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "VarianceGammaProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (FFTVarianceGammaEnginePtr *)new_FFTVarianceGammaEnginePtr__SWIG_0((VarianceGammaProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FFTVarianceGammaEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  VarianceGammaProcessPtr *arg1 = 0 ;
  FFTVarianceGammaEnginePtr *result = 0 ;
  
  arg1 = (VarianceGammaProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "VarianceGammaProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FFTVarianceGammaEnginePtr *)new_FFTVarianceGammaEnginePtr__SWIG_0((VarianceGammaProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FFTVarianceGammaEngine_precalculate(void * jarg1, void * jarg2) {
  FFTVarianceGammaEnginePtr *arg1 = (FFTVarianceGammaEnginePtr *) 0 ;
  std::vector< boost::shared_ptr< Instrument > > *arg2 = 0 ;
  
  arg1 = (FFTVarianceGammaEnginePtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Instrument > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Instrument > > const & type is null", 0);
    return ;
  } 
  {
    try {
      FFTVarianceGammaEnginePtr_precalculate(arg1,(std::vector< boost::shared_ptr< Instrument > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FFTVarianceGammaEngine(void * jarg1) {
  FFTVarianceGammaEnginePtr *arg1 = (FFTVarianceGammaEnginePtr *) 0 ;
  
  arg1 = (FFTVarianceGammaEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DoubleBarrierOption(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  DoubleBarrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  boost::shared_ptr< Payoff > *arg5 = 0 ;
  boost::shared_ptr< Exercise > *arg6 = 0 ;
  DoubleBarrierOptionPtr *result = 0 ;
  
  arg1 = (DoubleBarrier::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (boost::shared_ptr< Payoff > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg6 = (boost::shared_ptr< Exercise > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DoubleBarrierOptionPtr *)new_DoubleBarrierOptionPtr(arg1,arg2,arg3,arg4,(boost::shared_ptr< Payoff > const &)*arg5,(boost::shared_ptr< Exercise > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_delta(void * jarg1) {
  double jresult ;
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DoubleBarrierOptionPtr_delta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_gamma(void * jarg1) {
  double jresult ;
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DoubleBarrierOptionPtr_gamma(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_theta(void * jarg1) {
  double jresult ;
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DoubleBarrierOptionPtr_theta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_thetaPerDay(void * jarg1) {
  double jresult ;
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DoubleBarrierOptionPtr_thetaPerDay(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_vega(void * jarg1) {
  double jresult ;
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DoubleBarrierOptionPtr_vega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_rho(void * jarg1) {
  double jresult ;
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DoubleBarrierOptionPtr_rho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_dividendRho(void * jarg1) {
  double jresult ;
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DoubleBarrierOptionPtr_dividendRho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_strikeSensitivity(void * jarg1) {
  double jresult ;
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)DoubleBarrierOptionPtr_strikeSensitivity(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DoubleBarrierOption(void * jarg1) {
  DoubleBarrierOptionPtr *arg1 = (DoubleBarrierOptionPtr *) 0 ;
  
  arg1 = (DoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuantoDoubleBarrierOption(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  DoubleBarrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  boost::shared_ptr< Payoff > *arg5 = 0 ;
  boost::shared_ptr< Exercise > *arg6 = 0 ;
  QuantoDoubleBarrierOptionPtr *result = 0 ;
  
  arg1 = (DoubleBarrier::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (boost::shared_ptr< Payoff > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg6 = (boost::shared_ptr< Exercise > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantoDoubleBarrierOptionPtr *)new_QuantoDoubleBarrierOptionPtr(arg1,arg2,arg3,arg4,(boost::shared_ptr< Payoff > const &)*arg5,(boost::shared_ptr< Exercise > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuantoDoubleBarrierOption_qvega(void * jarg1) {
  double jresult ;
  QuantoDoubleBarrierOptionPtr *arg1 = (QuantoDoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (QuantoDoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)QuantoDoubleBarrierOptionPtr_qvega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuantoDoubleBarrierOption_qrho(void * jarg1) {
  double jresult ;
  QuantoDoubleBarrierOptionPtr *arg1 = (QuantoDoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (QuantoDoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)QuantoDoubleBarrierOptionPtr_qrho(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuantoDoubleBarrierOption_qlambda(void * jarg1) {
  double jresult ;
  QuantoDoubleBarrierOptionPtr *arg1 = (QuantoDoubleBarrierOptionPtr *) 0 ;
  Real result;
  
  arg1 = (QuantoDoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      result = (Real)QuantoDoubleBarrierOptionPtr_qlambda(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoDoubleBarrierOption(void * jarg1) {
  QuantoDoubleBarrierOptionPtr *arg1 = (QuantoDoubleBarrierOptionPtr *) 0 ;
  
  arg1 = (QuantoDoubleBarrierOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDoubleBarrierEngine__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  int arg2 ;
  AnalyticDoubleBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      result = (AnalyticDoubleBarrierEnginePtr *)new_AnalyticDoubleBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDoubleBarrierEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticDoubleBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticDoubleBarrierEnginePtr *)new_AnalyticDoubleBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDoubleBarrierEngine(void * jarg1) {
  AnalyticDoubleBarrierEnginePtr *arg1 = (AnalyticDoubleBarrierEnginePtr *) 0 ;
  
  arg1 = (AnalyticDoubleBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_WulinYongDoubleBarrierEngine__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  int arg2 ;
  WulinYongDoubleBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      result = (WulinYongDoubleBarrierEnginePtr *)new_WulinYongDoubleBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_WulinYongDoubleBarrierEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  WulinYongDoubleBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (WulinYongDoubleBarrierEnginePtr *)new_WulinYongDoubleBarrierEnginePtr__SWIG_0((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_WulinYongDoubleBarrierEngine(void * jarg1) {
  WulinYongDoubleBarrierEnginePtr *arg1 = (WulinYongDoubleBarrierEnginePtr *) 0 ;
  
  arg1 = (WulinYongDoubleBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__DeltaVolQuote(void * jarg1) {
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  
  arg1 = (DeltaVolQuote *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DeltaVolQuote > *arg1 = (boost::shared_ptr< DeltaVolQuote > *) 0 ;
  DeltaVolQuote *result = 0 ;
  
  arg1 = (boost::shared_ptr< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (DeltaVolQuote *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< DeltaVolQuote > *arg1 = (boost::shared_ptr< DeltaVolQuote > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_DeltaVolQuote_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DeltaVolQuote > *arg1 = (boost::shared_ptr< DeltaVolQuote > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_DeltaVolQuote_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_Spot_get() {
  int jresult ;
  enum DeltaVolQuote::DeltaType result;
  
  result = (enum DeltaVolQuote::DeltaType)DeltaVolQuote::Spot;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_Fwd_get() {
  int jresult ;
  enum DeltaVolQuote::DeltaType result;
  
  result = (enum DeltaVolQuote::DeltaType)DeltaVolQuote::Fwd;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_PaSpot_get() {
  int jresult ;
  enum DeltaVolQuote::DeltaType result;
  
  result = (enum DeltaVolQuote::DeltaType)DeltaVolQuote::PaSpot;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_PaFwd_get() {
  int jresult ;
  enum DeltaVolQuote::DeltaType result;
  
  result = (enum DeltaVolQuote::DeltaType)DeltaVolQuote::PaFwd;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_AtmNull_get() {
  int jresult ;
  enum DeltaVolQuote::AtmType result;
  
  result = (enum DeltaVolQuote::AtmType)DeltaVolQuote::AtmNull;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_AtmSpot_get() {
  int jresult ;
  enum DeltaVolQuote::AtmType result;
  
  result = (enum DeltaVolQuote::AtmType)DeltaVolQuote::AtmSpot;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_AtmFwd_get() {
  int jresult ;
  enum DeltaVolQuote::AtmType result;
  
  result = (enum DeltaVolQuote::AtmType)DeltaVolQuote::AtmFwd;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_AtmDeltaNeutral_get() {
  int jresult ;
  enum DeltaVolQuote::AtmType result;
  
  result = (enum DeltaVolQuote::AtmType)DeltaVolQuote::AtmDeltaNeutral;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_AtmVegaMax_get() {
  int jresult ;
  enum DeltaVolQuote::AtmType result;
  
  result = (enum DeltaVolQuote::AtmType)DeltaVolQuote::AtmVegaMax;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_AtmGammaMax_get() {
  int jresult ;
  enum DeltaVolQuote::AtmType result;
  
  result = (enum DeltaVolQuote::AtmType)DeltaVolQuote::AtmGammaMax;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_AtmPutCall50_get() {
  int jresult ;
  enum DeltaVolQuote::AtmType result;
  
  result = (enum DeltaVolQuote::AtmType)DeltaVolQuote::AtmPutCall50;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DeltaVolQuote__SWIG_0(double jarg1, void * jarg2, double jarg3, int jarg4) {
  void * jresult ;
  Real arg1 ;
  Handle< Quote > *arg2 = 0 ;
  Time arg3 ;
  DeltaVolQuote::DeltaType arg4 ;
  boost::shared_ptr< DeltaVolQuote > *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (DeltaVolQuote::DeltaType)jarg4; 
  {
    try {
      result = (boost::shared_ptr< DeltaVolQuote > *)new_boost_shared_ptr_Sl_DeltaVolQuote_Sg___SWIG_0(arg1,(Handle< Quote > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DeltaVolQuote__SWIG_1(void * jarg1, int jarg2, double jarg3, int jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  DeltaVolQuote::DeltaType arg2 ;
  Time arg3 ;
  DeltaVolQuote::AtmType arg4 ;
  boost::shared_ptr< DeltaVolQuote > *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (DeltaVolQuote::DeltaType)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (DeltaVolQuote::AtmType)jarg4; 
  {
    try {
      result = (boost::shared_ptr< DeltaVolQuote > *)new_boost_shared_ptr_Sl_DeltaVolQuote_Sg___SWIG_1((Handle< Quote > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DeltaVolQuote(void * jarg1) {
  boost::shared_ptr< DeltaVolQuote > *arg1 = (boost::shared_ptr< DeltaVolQuote > *) 0 ;
  
  arg1 = (boost::shared_ptr< DeltaVolQuote > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_value(void * jarg1) {
  double jresult ;
  boost::shared_ptr< DeltaVolQuote > *arg1 = (boost::shared_ptr< DeltaVolQuote > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->value();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DeltaVolQuoteHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DeltaVolQuote > *arg1 = 0 ;
  Handle< DeltaVolQuote > *result = 0 ;
  
  arg1 = (boost::shared_ptr< DeltaVolQuote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DeltaVolQuote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< DeltaVolQuote > *)new Handle< DeltaVolQuote >((boost::shared_ptr< DeltaVolQuote > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DeltaVolQuoteHandle__SWIG_1() {
  void * jresult ;
  Handle< DeltaVolQuote > *result = 0 ;
  
  {
    try {
      result = (Handle< DeltaVolQuote > *)new Handle< DeltaVolQuote >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DeltaVolQuoteHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  SwigValueWrapper< boost::shared_ptr< DeltaVolQuote > > result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< DeltaVolQuote >((const boost::shared_ptr< DeltaVolQuote > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuoteHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  bool result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DeltaVolQuoteHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = Handle_Sl_DeltaVolQuote_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DeltaVolQuoteHandle(void * jarg1) {
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DeltaVolQuoteHandle_value(void * jarg1) {
  double jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  Real result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->value();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableDeltaVolQuoteHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DeltaVolQuote > *arg1 = 0 ;
  RelinkableHandle< DeltaVolQuote > *result = 0 ;
  
  arg1 = (boost::shared_ptr< DeltaVolQuote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DeltaVolQuote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< DeltaVolQuote > *)new RelinkableHandle< DeltaVolQuote >((boost::shared_ptr< DeltaVolQuote > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableDeltaVolQuoteHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< DeltaVolQuote > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< DeltaVolQuote > *)new RelinkableHandle< DeltaVolQuote >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableDeltaVolQuoteHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< DeltaVolQuote > *arg1 = (RelinkableHandle< DeltaVolQuote > *) 0 ;
  boost::shared_ptr< DeltaVolQuote > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< DeltaVolQuote > *)jarg1; 
  arg2 = (boost::shared_ptr< DeltaVolQuote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DeltaVolQuote > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< DeltaVolQuote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableDeltaVolQuoteHandle(void * jarg1) {
  RelinkableHandle< DeltaVolQuote > *arg1 = (RelinkableHandle< DeltaVolQuote > *) 0 ;
  
  arg1 = (RelinkableHandle< DeltaVolQuote > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaDoubleBarrierEngine__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, char * jarg7, unsigned int jarg8, double jarg9, int jarg10) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  std::string *arg7 = 0 ;
  bool arg8 ;
  Real arg9 ;
  int arg10 ;
  Handle< DeltaVolQuote > const *argp1 ;
  Handle< DeltaVolQuote > const *argp2 ;
  Handle< DeltaVolQuote > const *argp3 ;
  Handle< Quote > const *argp4 ;
  Handle< YieldTermStructure > const *argp5 ;
  Handle< YieldTermStructure > const *argp6 ;
  VannaVolgaDoubleBarrierEnginePtr *result = 0 ;
  
  argp1 = (Handle< DeltaVolQuote > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (Handle< DeltaVolQuote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< DeltaVolQuote > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote > const", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Handle< YieldTermStructure > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg5 = *argp5; 
  argp6 = (Handle< YieldTermStructure > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg6 = *argp6; 
  if (!jarg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg7_str(jarg7);
  arg7 = &arg7_str; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Real)jarg9; 
  arg10 = (int)jarg10; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEnginePtr *)new_VannaVolgaDoubleBarrierEnginePtr__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,(std::string const &)*arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaDoubleBarrierEngine__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, char * jarg7, unsigned int jarg8, double jarg9) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  std::string *arg7 = 0 ;
  bool arg8 ;
  Real arg9 ;
  Handle< DeltaVolQuote > const *argp1 ;
  Handle< DeltaVolQuote > const *argp2 ;
  Handle< DeltaVolQuote > const *argp3 ;
  Handle< Quote > const *argp4 ;
  Handle< YieldTermStructure > const *argp5 ;
  Handle< YieldTermStructure > const *argp6 ;
  VannaVolgaDoubleBarrierEnginePtr *result = 0 ;
  
  argp1 = (Handle< DeltaVolQuote > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (Handle< DeltaVolQuote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< DeltaVolQuote > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote > const", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Handle< YieldTermStructure > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg5 = *argp5; 
  argp6 = (Handle< YieldTermStructure > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg6 = *argp6; 
  if (!jarg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg7_str(jarg7);
  arg7 = &arg7_str; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEnginePtr *)new_VannaVolgaDoubleBarrierEnginePtr__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,(std::string const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaDoubleBarrierEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, char * jarg7, unsigned int jarg8) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  std::string *arg7 = 0 ;
  bool arg8 ;
  Handle< DeltaVolQuote > const *argp1 ;
  Handle< DeltaVolQuote > const *argp2 ;
  Handle< DeltaVolQuote > const *argp3 ;
  Handle< Quote > const *argp4 ;
  Handle< YieldTermStructure > const *argp5 ;
  Handle< YieldTermStructure > const *argp6 ;
  VannaVolgaDoubleBarrierEnginePtr *result = 0 ;
  
  argp1 = (Handle< DeltaVolQuote > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (Handle< DeltaVolQuote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< DeltaVolQuote > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote > const", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Handle< YieldTermStructure > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg5 = *argp5; 
  argp6 = (Handle< YieldTermStructure > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg6 = *argp6; 
  if (!jarg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg7_str(jarg7);
  arg7 = &arg7_str; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEnginePtr *)new_VannaVolgaDoubleBarrierEnginePtr__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,(std::string const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaDoubleBarrierEngine__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, char * jarg7) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  std::string *arg7 = 0 ;
  Handle< DeltaVolQuote > const *argp1 ;
  Handle< DeltaVolQuote > const *argp2 ;
  Handle< DeltaVolQuote > const *argp3 ;
  Handle< Quote > const *argp4 ;
  Handle< YieldTermStructure > const *argp5 ;
  Handle< YieldTermStructure > const *argp6 ;
  VannaVolgaDoubleBarrierEnginePtr *result = 0 ;
  
  argp1 = (Handle< DeltaVolQuote > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (Handle< DeltaVolQuote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< DeltaVolQuote > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote > const", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Handle< YieldTermStructure > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg5 = *argp5; 
  argp6 = (Handle< YieldTermStructure > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg6 = *argp6; 
  if (!jarg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg7_str(jarg7);
  arg7 = &arg7_str; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEnginePtr *)new_VannaVolgaDoubleBarrierEnginePtr__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,(std::string const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaDoubleBarrierEngine__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  Handle< DeltaVolQuote > const *argp1 ;
  Handle< DeltaVolQuote > const *argp2 ;
  Handle< DeltaVolQuote > const *argp3 ;
  Handle< Quote > const *argp4 ;
  Handle< YieldTermStructure > const *argp5 ;
  Handle< YieldTermStructure > const *argp6 ;
  VannaVolgaDoubleBarrierEnginePtr *result = 0 ;
  
  argp1 = (Handle< DeltaVolQuote > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (Handle< DeltaVolQuote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< DeltaVolQuote > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< DeltaVolQuote > const", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote > const", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Handle< YieldTermStructure > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg5 = *argp5; 
  argp6 = (Handle< YieldTermStructure > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure > const", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEnginePtr *)new_VannaVolgaDoubleBarrierEnginePtr__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VannaVolgaDoubleBarrierEngine(void * jarg1) {
  VannaVolgaDoubleBarrierEnginePtr *arg1 = (VannaVolgaDoubleBarrierEnginePtr *) 0 ;
  
  arg1 = (VannaVolgaDoubleBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDoubleBarrierBinaryEngine(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  AnalyticDoubleBarrierBinaryEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticDoubleBarrierBinaryEnginePtr *)new_AnalyticDoubleBarrierBinaryEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDoubleBarrierBinaryEngine(void * jarg1) {
  AnalyticDoubleBarrierBinaryEnginePtr *arg1 = (AnalyticDoubleBarrierBinaryEnginePtr *) 0 ;
  
  arg1 = (AnalyticDoubleBarrierBinaryEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialDoubleBarrierEngine(void * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  BinomialDoubleBarrierEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialDoubleBarrierEnginePtr *)new_BinomialDoubleBarrierEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialDoubleBarrierEngine(void * jarg1) {
  BinomialDoubleBarrierEnginePtr *arg1 = (BinomialDoubleBarrierEnginePtr *) 0 ;
  
  arg1 = (BinomialDoubleBarrierEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PlainVanillaPayoff(int jarg1, double jarg2) {
  void * jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  PlainVanillaPayoffPtr *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (PlainVanillaPayoffPtr *)new_PlainVanillaPayoffPtr(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_PlainVanillaPayoff_optionType(void * jarg1) {
  int jresult ;
  PlainVanillaPayoffPtr *arg1 = (PlainVanillaPayoffPtr *) 0 ;
  Option::Type result;
  
  arg1 = (PlainVanillaPayoffPtr *)jarg1; 
  {
    try {
      result = (Option::Type)PlainVanillaPayoffPtr_optionType(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PlainVanillaPayoff_strike(void * jarg1) {
  double jresult ;
  PlainVanillaPayoffPtr *arg1 = (PlainVanillaPayoffPtr *) 0 ;
  Real result;
  
  arg1 = (PlainVanillaPayoffPtr *)jarg1; 
  {
    try {
      result = (Real)PlainVanillaPayoffPtr_strike(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PlainVanillaPayoff(void * jarg1) {
  PlainVanillaPayoffPtr *arg1 = (PlainVanillaPayoffPtr *) 0 ;
  
  arg1 = (PlainVanillaPayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PercentageStrikePayoff(int jarg1, double jarg2) {
  void * jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  PercentageStrikePayoffPtr *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (PercentageStrikePayoffPtr *)new_PercentageStrikePayoffPtr(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PercentageStrikePayoff(void * jarg1) {
  PercentageStrikePayoffPtr *arg1 = (PercentageStrikePayoffPtr *) 0 ;
  
  arg1 = (PercentageStrikePayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CashOrNothingPayoff(int jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  CashOrNothingPayoffPtr *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (CashOrNothingPayoffPtr *)new_CashOrNothingPayoffPtr(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CashOrNothingPayoff(void * jarg1) {
  CashOrNothingPayoffPtr *arg1 = (CashOrNothingPayoffPtr *) 0 ;
  
  arg1 = (CashOrNothingPayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AssetOrNothingPayoff(int jarg1, double jarg2) {
  void * jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  AssetOrNothingPayoffPtr *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (AssetOrNothingPayoffPtr *)new_AssetOrNothingPayoffPtr(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AssetOrNothingPayoff(void * jarg1) {
  AssetOrNothingPayoffPtr *arg1 = (AssetOrNothingPayoffPtr *) 0 ;
  
  arg1 = (AssetOrNothingPayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SuperSharePayoff(int jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  SuperSharePayoffPtr *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (SuperSharePayoffPtr *)new_SuperSharePayoffPtr(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SuperSharePayoff(void * jarg1) {
  SuperSharePayoffPtr *arg1 = (SuperSharePayoffPtr *) 0 ;
  
  arg1 = (SuperSharePayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GapPayoff(int jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  GapPayoffPtr *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (GapPayoffPtr *)new_GapPayoffPtr(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GapPayoff(void * jarg1) {
  GapPayoffPtr *arg1 = (GapPayoffPtr *) 0 ;
  
  arg1 = (GapPayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BasketPayoff() {
  void * jresult ;
  BasketPayoffPtr *result = 0 ;
  
  {
    try {
      result = (BasketPayoffPtr *)new BasketPayoffPtr();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BasketPayoff(void * jarg1) {
  BasketPayoffPtr *arg1 = (BasketPayoffPtr *) 0 ;
  
  arg1 = (BasketPayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MinBasketPayoff(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Payoff > arg1 ;
  boost::shared_ptr< Payoff > const *argp1 ;
  MinBasketPayoffPtr *result = 0 ;
  
  argp1 = (boost::shared_ptr< Payoff > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Payoff > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (MinBasketPayoffPtr *)new_MinBasketPayoffPtr(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MinBasketPayoff(void * jarg1) {
  MinBasketPayoffPtr *arg1 = (MinBasketPayoffPtr *) 0 ;
  
  arg1 = (MinBasketPayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MaxBasketPayoff(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Payoff > arg1 ;
  boost::shared_ptr< Payoff > const *argp1 ;
  MaxBasketPayoffPtr *result = 0 ;
  
  argp1 = (boost::shared_ptr< Payoff > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Payoff > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (MaxBasketPayoffPtr *)new_MaxBasketPayoffPtr(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MaxBasketPayoff(void * jarg1) {
  MaxBasketPayoffPtr *arg1 = (MaxBasketPayoffPtr *) 0 ;
  
  arg1 = (MaxBasketPayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AverageBasketPayoff__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< Payoff > arg1 ;
  Array *arg2 = 0 ;
  boost::shared_ptr< Payoff > const *argp1 ;
  AverageBasketPayoffPtr *result = 0 ;
  
  argp1 = (boost::shared_ptr< Payoff > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Payoff > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AverageBasketPayoffPtr *)new_AverageBasketPayoffPtr__SWIG_0(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AverageBasketPayoff__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  boost::shared_ptr< Payoff > arg1 ;
  Size arg2 ;
  boost::shared_ptr< Payoff > const *argp1 ;
  AverageBasketPayoffPtr *result = 0 ;
  
  argp1 = (boost::shared_ptr< Payoff > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Payoff > const", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (AverageBasketPayoffPtr *)new_AverageBasketPayoffPtr__SWIG_1(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AverageBasketPayoff(void * jarg1) {
  AverageBasketPayoffPtr *arg1 = (AverageBasketPayoffPtr *) 0 ;
  
  arg1 = (AverageBasketPayoffPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BasketOption(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< Payoff > *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  BasketOptionPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Payoff > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Payoff > const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BasketOptionPtr *)new_BasketOptionPtr((boost::shared_ptr< Payoff > const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BasketOption(void * jarg1) {
  BasketOptionPtr *arg1 = (BasketOptionPtr *) 0 ;
  
  arg1 = (BasketOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_0(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9, long jarg10) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  BigInteger arg10 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  arg10 = (BigInteger)jarg10; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_1(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_2(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_3(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_4(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_5(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_6(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_7(void * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEuropeanBasketEngine__SWIG_8(void * jarg1, char * jarg2) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCEuropeanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCEuropeanBasketEnginePtr *)new_MCEuropeanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCEuropeanBasketEngine(void * jarg1) {
  MCEuropeanBasketEnginePtr *arg1 = (MCEuropeanBasketEnginePtr *) 0 ;
  
  arg1 = (MCEuropeanBasketEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_0(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9, long jarg10) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  BigInteger arg10 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  arg10 = (BigInteger)jarg10; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_1(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_2(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_3(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_4(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_5(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_6(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_7(void * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCAmericanBasketEngine__SWIG_8(void * jarg1, char * jarg2) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCAmericanBasketEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCAmericanBasketEnginePtr *)new_MCAmericanBasketEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCAmericanBasketEngine(void * jarg1) {
  MCAmericanBasketEnginePtr *arg1 = (MCAmericanBasketEnginePtr *) 0 ;
  
  arg1 = (MCAmericanBasketEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StulzEngine(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  GeneralizedBlackScholesProcessPtr *arg2 = 0 ;
  Real arg3 ;
  StulzEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (GeneralizedBlackScholesProcessPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (StulzEnginePtr *)new_StulzEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1,(GeneralizedBlackScholesProcessPtr const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StulzEngine(void * jarg1) {
  StulzEnginePtr *arg1 = (StulzEnginePtr *) 0 ;
  
  arg1 = (StulzEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EverestOption(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  Rate arg2 ;
  boost::shared_ptr< Exercise > *arg3 = 0 ;
  EverestOptionPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (boost::shared_ptr< Exercise > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EverestOptionPtr *)new_EverestOptionPtr(arg1,arg2,(boost::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EverestOption(void * jarg1) {
  EverestOptionPtr *arg1 = (EverestOptionPtr *) 0 ;
  
  arg1 = (EverestOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_0(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9, long jarg10) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  BigInteger arg10 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  arg10 = (BigInteger)jarg10; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_1(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  intOrNull arg9 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  arg9 = (intOrNull)jarg9; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_2(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7, double jarg8) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  doubleOrNull arg8 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (doubleOrNull)jarg8; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_3(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  intOrNull arg7 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_4(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5, unsigned int jarg6) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  bool arg6 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_5(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned int jarg5) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  bool arg5 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_6(void * jarg1, char * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_7(void * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCEverestEngine__SWIG_8(void * jarg1, char * jarg2) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCEverestEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCEverestEnginePtr *)new_MCEverestEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCEverestEngine(void * jarg1) {
  MCEverestEnginePtr *arg1 = (MCEverestEnginePtr *) 0 ;
  
  arg1 = (MCEverestEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HimalayaOption(void * jarg1, double jarg2) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  Real arg2 ;
  HimalayaOptionPtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (HimalayaOptionPtr *)new_HimalayaOptionPtr((std::vector< Date > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HimalayaOption(void * jarg1) {
  HimalayaOptionPtr *arg1 = (HimalayaOptionPtr *) 0 ;
  
  arg1 = (HimalayaOptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCHimalayaEngine__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  MCHimalayaEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCHimalayaEnginePtr *)new_MCHimalayaEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCHimalayaEngine__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  MCHimalayaEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCHimalayaEnginePtr *)new_MCHimalayaEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCHimalayaEngine__SWIG_2(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  MCHimalayaEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCHimalayaEnginePtr *)new_MCHimalayaEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCHimalayaEngine__SWIG_3(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  MCHimalayaEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCHimalayaEnginePtr *)new_MCHimalayaEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCHimalayaEngine__SWIG_4(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  MCHimalayaEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCHimalayaEnginePtr *)new_MCHimalayaEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCHimalayaEngine__SWIG_5(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  MCHimalayaEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCHimalayaEnginePtr *)new_MCHimalayaEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCHimalayaEngine__SWIG_6(void * jarg1, char * jarg2) {
  void * jresult ;
  StochasticProcessArrayPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  MCHimalayaEnginePtr *result = 0 ;
  
  arg1 = (StochasticProcessArrayPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcessArrayPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (MCHimalayaEnginePtr *)new_MCHimalayaEnginePtr__SWIG_0((StochasticProcessArrayPtr const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCHimalayaEngine(void * jarg1) {
  MCHimalayaEnginePtr *arg1 = (MCHimalayaEnginePtr *) 0 ;
  
  arg1 = (MCHimalayaEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormula__SWIG_0(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)blackFormula(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormula__SWIG_1(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)blackFormula(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormula__SWIG_2(int jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)blackFormula(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDev__SWIG_0(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Natural arg9 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Natural)jarg9; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDev__SWIG_1(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDev__SWIG_2(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDev__SWIG_3(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDev__SWIG_4(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDev__SWIG_5(int jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaCashItmProbability__SWIG_0(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)blackFormulaCashItmProbability(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaCashItmProbability__SWIG_1(int jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)blackFormulaCashItmProbability(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_bachelierBlackFormula__SWIG_0(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)bachelierBlackFormula(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_bachelierBlackFormula__SWIG_1(int jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)bachelierBlackFormula(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_bachelierBlackFormulaImpliedVol__SWIG_0(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)bachelierBlackFormulaImpliedVol(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_bachelierBlackFormulaImpliedVol__SWIG_1(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)bachelierBlackFormulaImpliedVol(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackDeltaCalculator(int jarg1, int jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  void * jresult ;
  Option::Type arg1 ;
  DeltaVolQuote::DeltaType arg2 ;
  Real arg3 ;
  DiscountFactor arg4 ;
  DiscountFactor arg5 ;
  Real arg6 ;
  BlackDeltaCalculator *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (DeltaVolQuote::DeltaType)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (DiscountFactor)jarg4; 
  arg5 = (DiscountFactor)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (BlackDeltaCalculator *)new BlackDeltaCalculator(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackDeltaCalculator_deltaFromStrike(void * jarg1, double jarg2) {
  double jresult ;
  BlackDeltaCalculator *arg1 = (BlackDeltaCalculator *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (BlackDeltaCalculator *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((BlackDeltaCalculator const *)arg1)->deltaFromStrike(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackDeltaCalculator_strikeFromDelta(void * jarg1, double jarg2) {
  double jresult ;
  BlackDeltaCalculator *arg1 = (BlackDeltaCalculator *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (BlackDeltaCalculator *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((BlackDeltaCalculator const *)arg1)->strikeFromDelta(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackDeltaCalculator_atmStrike(void * jarg1, int jarg2) {
  double jresult ;
  BlackDeltaCalculator *arg1 = (BlackDeltaCalculator *) 0 ;
  DeltaVolQuote::AtmType arg2 ;
  Real result;
  
  arg1 = (BlackDeltaCalculator *)jarg1; 
  arg2 = (DeltaVolQuote::AtmType)jarg2; 
  {
    try {
      result = (Real)((BlackDeltaCalculator const *)arg1)->atmStrike(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackDeltaCalculator(void * jarg1) {
  BlackDeltaCalculator *arg1 = (BlackDeltaCalculator *) 0 ;
  
  arg1 = (BlackDeltaCalculator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallabilityPrice(double jarg1, int jarg2) {
  void * jresult ;
  Real arg1 ;
  CallabilityPrice::Type arg2 ;
  CallabilityPrice *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (CallabilityPrice::Type)jarg2; 
  {
    try {
      result = (CallabilityPrice *)new CallabilityPrice(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallabilityPrice_amount(void * jarg1) {
  double jresult ;
  CallabilityPrice *arg1 = (CallabilityPrice *) 0 ;
  Real result;
  
  arg1 = (CallabilityPrice *)jarg1; 
  {
    try {
      result = (Real)((CallabilityPrice const *)arg1)->amount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CallabilityPrice_type(void * jarg1) {
  int jresult ;
  CallabilityPrice *arg1 = (CallabilityPrice *) 0 ;
  CallabilityPrice::Type result;
  
  arg1 = (CallabilityPrice *)jarg1; 
  {
    try {
      result = (CallabilityPrice::Type)((CallabilityPrice const *)arg1)->type();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CallabilityPrice(void * jarg1) {
  CallabilityPrice *arg1 = (CallabilityPrice *) 0 ;
  
  arg1 = (CallabilityPrice *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib__Callability_price(void * jarg1) {
  void * jresult ;
  Callability *arg1 = (Callability *) 0 ;
  CallabilityPrice *result = 0 ;
  
  arg1 = (Callability *)jarg1; 
  {
    try {
      result = (CallabilityPrice *) &((Callability const *)arg1)->price();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib__Callability_type(void * jarg1) {
  int jresult ;
  Callability *arg1 = (Callability *) 0 ;
  Callability::Type result;
  
  arg1 = (Callability *)jarg1; 
  {
    try {
      result = (Callability::Type)((Callability const *)arg1)->type();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib__Callability_date(void * jarg1) {
  void * jresult ;
  Callability *arg1 = (Callability *) 0 ;
  Date result;
  
  arg1 = (Callability *)jarg1; 
  {
    try {
      result = ((Callability const *)arg1)->date();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__Callability(void * jarg1) {
  Callability *arg1 = (Callability *) 0 ;
  
  arg1 = (Callability *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Callability___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Callability > *arg1 = (boost::shared_ptr< Callability > *) 0 ;
  Callability *result = 0 ;
  
  arg1 = (boost::shared_ptr< Callability > *)jarg1; 
  {
    try {
      result = (Callability *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Callability_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Callability > *arg1 = (boost::shared_ptr< Callability > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Callability > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Callability_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Callability(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  CallabilityPrice *arg1 = 0 ;
  Callability::Type arg2 ;
  Date *arg3 = 0 ;
  boost::shared_ptr< Callability > *result = 0 ;
  
  arg1 = (CallabilityPrice *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CallabilityPrice const & type is null", 0);
    return 0;
  } 
  arg2 = (Callability::Type)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (boost::shared_ptr< Callability > *)new_boost_shared_ptr_Sl_Callability_Sg_((CallabilityPrice const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Callability_Call_get() {
  int jresult ;
  enum Callability::Type result;
  
  result = (enum Callability::Type)Callability::Call;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Callability_Put_get() {
  int jresult ;
  enum Callability::Type result;
  
  result = (enum Callability::Type)Callability::Put;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Callability(void * jarg1) {
  boost::shared_ptr< Callability > *arg1 = (boost::shared_ptr< Callability > *) 0 ;
  
  arg1 = (boost::shared_ptr< Callability > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Callability_price(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Callability > *arg1 = (boost::shared_ptr< Callability > *) 0 ;
  CallabilityPrice *result = 0 ;
  
  arg1 = (boost::shared_ptr< Callability > *)jarg1; 
  {
    try {
      result = (CallabilityPrice *) &(*arg1)->price();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Callability_type(void * jarg1) {
  int jresult ;
  boost::shared_ptr< Callability > *arg1 = (boost::shared_ptr< Callability > *) 0 ;
  Callability::Type result;
  
  arg1 = (boost::shared_ptr< Callability > *)jarg1; 
  {
    try {
      result = (Callability::Type)(*arg1)->type();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Callability_date(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Callability > *arg1 = (boost::shared_ptr< Callability > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< Callability > *)jarg1; 
  {
    try {
      result = (*arg1)->date();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SoftCallability(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  CallabilityPrice *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  SoftCallabilityPtr *result = 0 ;
  
  arg1 = (CallabilityPrice *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CallabilityPrice const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (SoftCallabilityPtr *)new_SoftCallabilityPtr((CallabilityPrice const &)*arg1,(Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SoftCallability(void * jarg1) {
  SoftCallabilityPtr *arg1 = (SoftCallabilityPtr *) 0 ;
  
  arg1 = (SoftCallabilityPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  boost::shared_ptr< Callability > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (boost::shared_ptr< Callability > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Callability > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< Callability > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  std::vector< boost::shared_ptr< Callability > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< Callability > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  std::vector< boost::shared_ptr< Callability > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< Callability > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  std::vector< boost::shared_ptr< Callability > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Callability > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallabilitySchedule__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< Callability > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< Callability > > *)new std::vector< boost::shared_ptr< Callability > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallabilitySchedule__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< Callability > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< Callability > > *)new std::vector< boost::shared_ptr< Callability > >((std::vector< boost::shared_ptr< Callability > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallabilitySchedule__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< Callability > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Callability > > *)new_std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  SwigValueWrapper< boost::shared_ptr< Callability > > result;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Callability >((const boost::shared_ptr< Callability > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Callability > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< Callability > *) &std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Callability > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< Callability > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Callability > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< Callability > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  std::vector< boost::shared_ptr< Callability > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Callability > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< Callability > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< Callability > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Callability > > *)std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Callability > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< Callability > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Callability > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< Callability > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Callability > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< Callability > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< Callability > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Callability > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< Callability > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Callability > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Callability > > *)std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Repeat((boost::shared_ptr< Callability > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Callability > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< Callability > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  boost::shared_ptr< Callability > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (boost::shared_ptr< Callability > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Callability > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Contains(arg1,(boost::shared_ptr< Callability > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  boost::shared_ptr< Callability > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (boost::shared_ptr< Callability > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Callability > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< Callability > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  boost::shared_ptr< Callability > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (boost::shared_ptr< Callability > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Callability > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< Callability > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  boost::shared_ptr< Callability > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  arg2 = (boost::shared_ptr< Callability > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Callability > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_Callability_Sg__Sg__Remove(arg1,(boost::shared_ptr< Callability > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CallabilitySchedule(void * jarg1) {
  std::vector< boost::shared_ptr< Callability > > *arg1 = (std::vector< boost::shared_ptr< Callability > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Callability > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Seasonality___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Seasonality > *arg1 = (boost::shared_ptr< Seasonality > *) 0 ;
  Seasonality *result = 0 ;
  
  arg1 = (boost::shared_ptr< Seasonality > *)jarg1; 
  {
    try {
      result = (Seasonality *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Seasonality_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Seasonality > *arg1 = (boost::shared_ptr< Seasonality > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Seasonality > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Seasonality_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Seasonality() {
  void * jresult ;
  boost::shared_ptr< Seasonality > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Seasonality > *)new boost::shared_ptr< Seasonality >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Seasonality(void * jarg1) {
  boost::shared_ptr< Seasonality > *arg1 = (boost::shared_ptr< Seasonality > *) 0 ;
  
  arg1 = (boost::shared_ptr< Seasonality > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Seasonality_correctZeroRate(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  boost::shared_ptr< Seasonality > *arg1 = (boost::shared_ptr< Seasonality > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  InflationTermStructure *arg4 = 0 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< Seasonality > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (InflationTermStructure *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InflationTermStructure const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->correctZeroRate((Date const &)*arg2,arg3,(InflationTermStructure const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Seasonality_correctYoYRate(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  boost::shared_ptr< Seasonality > *arg1 = (boost::shared_ptr< Seasonality > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  InflationTermStructure *arg4 = 0 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< Seasonality > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (InflationTermStructure *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InflationTermStructure const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->correctYoYRate((Date const &)*arg2,arg3,(InflationTermStructure const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Seasonality_isConsistent(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  boost::shared_ptr< Seasonality > *arg1 = (boost::shared_ptr< Seasonality > *) 0 ;
  InflationTermStructure *arg2 = 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Seasonality > *)jarg1; 
  arg2 = (InflationTermStructure *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InflationTermStructure const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)(*arg1)->isConsistent((InflationTermStructure const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MultiplicativePriceSeasonalityPtr(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Frequency arg2 ;
  std::vector< Rate > *arg3 = 0 ;
  MultiplicativePriceSeasonalityPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Frequency)jarg2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MultiplicativePriceSeasonalityPtr *)new_MultiplicativePriceSeasonalityPtr((Date const &)*arg1,arg2,(std::vector< double > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MultiplicativePriceSeasonalityPtr(void * jarg1) {
  MultiplicativePriceSeasonalityPtr *arg1 = (MultiplicativePriceSeasonalityPtr *) 0 ;
  
  arg1 = (MultiplicativePriceSeasonalityPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  YoYInflationTermStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (YoYInflationTermStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_YoYInflationTermStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_YoYInflationTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationTermStructure() {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< YoYInflationTermStructure > *)new boost::shared_ptr< YoYInflationTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationTermStructure(void * jarg1) {
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_yoyRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_yoyRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_yoyRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_yoyRate__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_referenceDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_maxDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_maxTime(void * jarg1) {
  double jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Time result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_observationLag(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Period result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->observationLag();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_frequency(void * jarg1) {
  int jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Frequency result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Frequency)(*arg1)->frequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_indexIsInterpolated(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->indexIsInterpolated();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_baseRate(void * jarg1) {
  double jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Rate)(*arg1)->baseRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_nominalTermStructure(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->nominalTermStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_baseDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->baseDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_setSeasonality__SWIG_0(void * jarg1, void * jarg2) {
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  boost::shared_ptr< Seasonality > *arg2 = 0 ;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< Seasonality > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Seasonality > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setSeasonality((boost::shared_ptr< Seasonality > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_setSeasonality__SWIG_1(void * jarg1) {
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->setSeasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_seasonality(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  boost::shared_ptr< Seasonality > result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->seasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Seasonality >((const boost::shared_ptr< Seasonality > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_hasSeasonality(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->hasSeasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = (boost::shared_ptr< YoYInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = 0 ;
  Handle< YoYInflationTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< YoYInflationTermStructure > *)new Handle< YoYInflationTermStructure >((boost::shared_ptr< YoYInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationTermStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< YoYInflationTermStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< YoYInflationTermStructure > *)new Handle< YoYInflationTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  boost::shared_ptr< YoYInflationTermStructure > result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< YoYInflationTermStructure >((const boost::shared_ptr< YoYInflationTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_YoYInflationTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationTermStructureHandle(void * jarg1) {
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_yoyRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  Rate result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_yoyRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  Rate result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_yoyRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_yoyRate__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_observationLag(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Period result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->observationLag();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_frequency(void * jarg1) {
  int jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Frequency result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Frequency)(*arg1)->frequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_indexIsInterpolated(void * jarg1) {
  unsigned int jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->indexIsInterpolated();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_baseRate(void * jarg1) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Rate result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Rate)(*arg1)->baseRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_nominalTermStructure(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->nominalTermStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_baseDate(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->baseDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_setSeasonality__SWIG_0(void * jarg1, void * jarg2) {
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  boost::shared_ptr< Seasonality > *arg2 = 0 ;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< Seasonality > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Seasonality > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setSeasonality((boost::shared_ptr< Seasonality > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_setSeasonality__SWIG_1(void * jarg1) {
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->setSeasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_seasonality(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  boost::shared_ptr< Seasonality > result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->seasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Seasonality >((const boost::shared_ptr< Seasonality > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_hasSeasonality(void * jarg1) {
  unsigned int jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->hasSeasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableYoYInflationTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYInflationTermStructure > *arg1 = 0 ;
  RelinkableHandle< YoYInflationTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< YoYInflationTermStructure > *)new RelinkableHandle< YoYInflationTermStructure >((boost::shared_ptr< YoYInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableYoYInflationTermStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< YoYInflationTermStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< YoYInflationTermStructure > *)new RelinkableHandle< YoYInflationTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableYoYInflationTermStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< YoYInflationTermStructure > *arg1 = (RelinkableHandle< YoYInflationTermStructure > *) 0 ;
  boost::shared_ptr< YoYInflationTermStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYInflationTermStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableYoYInflationTermStructureHandle(void * jarg1) {
  RelinkableHandle< YoYInflationTermStructure > *arg1 = (RelinkableHandle< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  ZeroInflationTermStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (ZeroInflationTermStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_ZeroInflationTermStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_ZeroInflationTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationTermStructure() {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< ZeroInflationTermStructure > *)new boost::shared_ptr< ZeroInflationTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroInflationTermStructure(void * jarg1) {
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_zeroRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) {
  double jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_zeroRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_zeroRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_zeroRate__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_referenceDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_maxDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_maxTime(void * jarg1) {
  double jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Time result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_observationLag(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Period result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->observationLag();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_frequency(void * jarg1) {
  int jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Frequency result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Frequency)(*arg1)->frequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_indexIsInterpolated(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->indexIsInterpolated();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_baseRate(void * jarg1) {
  double jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Rate result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Rate)(*arg1)->baseRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_nominalTermStructure(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->nominalTermStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_baseDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->baseDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_setSeasonality__SWIG_0(void * jarg1, void * jarg2) {
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  boost::shared_ptr< Seasonality > *arg2 = 0 ;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< Seasonality > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Seasonality > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setSeasonality((boost::shared_ptr< Seasonality > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_setSeasonality__SWIG_1(void * jarg1) {
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->setSeasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_seasonality(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  boost::shared_ptr< Seasonality > result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->seasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Seasonality >((const boost::shared_ptr< Seasonality > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_hasSeasonality(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->hasSeasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = 0 ;
  Handle< ZeroInflationTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< ZeroInflationTermStructure > *)new Handle< ZeroInflationTermStructure >((boost::shared_ptr< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationTermStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< ZeroInflationTermStructure > *)new Handle< ZeroInflationTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  boost::shared_ptr< ZeroInflationTermStructure > result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< ZeroInflationTermStructure >((const boost::shared_ptr< ZeroInflationTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_ZeroInflationTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroInflationTermStructureHandle(void * jarg1) {
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_zeroRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  Rate result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_zeroRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  Rate result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_zeroRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_zeroRate__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_observationLag(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Period result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->observationLag();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_frequency(void * jarg1) {
  int jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Frequency result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Frequency)(*arg1)->frequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_indexIsInterpolated(void * jarg1) {
  unsigned int jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->indexIsInterpolated();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_baseRate(void * jarg1) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Rate result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (Rate)(*arg1)->baseRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_nominalTermStructure(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Handle< YieldTermStructure > result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->nominalTermStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< YieldTermStructure >((const Handle< YieldTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_baseDate(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->baseDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_setSeasonality__SWIG_0(void * jarg1, void * jarg2) {
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  boost::shared_ptr< Seasonality > *arg2 = 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< Seasonality > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Seasonality > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setSeasonality((boost::shared_ptr< Seasonality > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_setSeasonality__SWIG_1(void * jarg1) {
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->setSeasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_seasonality(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  boost::shared_ptr< Seasonality > result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->seasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Seasonality >((const boost::shared_ptr< Seasonality > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_hasSeasonality(void * jarg1) {
  unsigned int jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->hasSeasonality();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableZeroInflationTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg1 = 0 ;
  RelinkableHandle< ZeroInflationTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< ZeroInflationTermStructure > *)new RelinkableHandle< ZeroInflationTermStructure >((boost::shared_ptr< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableZeroInflationTermStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< ZeroInflationTermStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< ZeroInflationTermStructure > *)new RelinkableHandle< ZeroInflationTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableZeroInflationTermStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< ZeroInflationTermStructure > *arg1 = (RelinkableHandle< ZeroInflationTermStructure > *) 0 ;
  boost::shared_ptr< ZeroInflationTermStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroInflationTermStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableZeroInflationTermStructureHandle(void * jarg1) {
  RelinkableHandle< ZeroInflationTermStructure > *arg1 = (RelinkableHandle< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Region_name(void * jarg1) {
  char * jresult ;
  Region *arg1 = (Region *) 0 ;
  std::string result;
  
  arg1 = (Region *)jarg1; 
  {
    try {
      result = ((Region const *)arg1)->name();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QuantLib_Region_code(void * jarg1) {
  char * jresult ;
  Region *arg1 = (Region *) 0 ;
  std::string result;
  
  arg1 = (Region *)jarg1; 
  {
    try {
      result = ((Region const *)arg1)->code();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Region(void * jarg1) {
  Region *arg1 = (Region *) 0 ;
  
  arg1 = (Region *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CustomRegion(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  CustomRegion *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (CustomRegion *)new CustomRegion((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CustomRegion(void * jarg1) {
  CustomRegion *arg1 = (CustomRegion *) 0 ;
  
  arg1 = (CustomRegion *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_InflationIndex_interpolated(void * jarg1) {
  unsigned int jresult ;
  InflationIndexPtr *arg1 = (InflationIndexPtr *) 0 ;
  bool result;
  
  arg1 = (InflationIndexPtr *)jarg1; 
  {
    try {
      result = (bool)InflationIndexPtr_interpolated((InflationIndexPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_InflationIndex_frequency(void * jarg1) {
  int jresult ;
  InflationIndexPtr *arg1 = (InflationIndexPtr *) 0 ;
  Frequency result;
  
  arg1 = (InflationIndexPtr *)jarg1; 
  {
    try {
      result = (Frequency)InflationIndexPtr_frequency((InflationIndexPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InflationIndex_availabilityLag(void * jarg1) {
  void * jresult ;
  InflationIndexPtr *arg1 = (InflationIndexPtr *) 0 ;
  Period result;
  
  arg1 = (InflationIndexPtr *)jarg1; 
  {
    try {
      result = InflationIndexPtr_availabilityLag((InflationIndexPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Period((const Period &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InflationIndex_currency(void * jarg1) {
  void * jresult ;
  InflationIndexPtr *arg1 = (InflationIndexPtr *) 0 ;
  Currency result;
  
  arg1 = (InflationIndexPtr *)jarg1; 
  {
    try {
      result = InflationIndexPtr_currency((InflationIndexPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Currency((const Currency &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InflationIndex(void * jarg1) {
  InflationIndexPtr *arg1 = (InflationIndexPtr *) 0 ;
  
  arg1 = (InflationIndexPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationIndex__SWIG_0(char * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  Frequency arg5 ;
  Period *arg6 = 0 ;
  Currency *arg7 = 0 ;
  Handle< ZeroInflationTermStructure > *arg8 = 0 ;
  ZeroInflationIndexPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Region *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Region const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg7 = (Currency *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< ZeroInflationTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroInflationIndexPtr *)new_ZeroInflationIndexPtr__SWIG_0((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,(Period const &)*arg6,(Currency const &)*arg7,(Handle< ZeroInflationTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationIndex__SWIG_1(char * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  Frequency arg5 ;
  Period *arg6 = 0 ;
  Currency *arg7 = 0 ;
  ZeroInflationIndexPtr *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Region *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Region const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg7 = (Currency *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroInflationIndexPtr *)new_ZeroInflationIndexPtr__SWIG_0((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,(Period const &)*arg6,(Currency const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroInflationIndex(void * jarg1) {
  ZeroInflationIndexPtr *arg1 = (ZeroInflationIndexPtr *) 0 ;
  
  arg1 = (ZeroInflationIndexPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationIndex(void * jarg1) {
  YoYInflationIndexPtr *arg1 = (YoYInflationIndexPtr *) 0 ;
  
  arg1 = (YoYInflationIndexPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EUHICP__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  EUHICPPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EUHICPPtr *)new_EUHICPPtr__SWIG_0(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EUHICP__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  EUHICPPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (EUHICPPtr *)new_EUHICPPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EUHICP(void * jarg1) {
  EUHICPPtr *arg1 = (EUHICPPtr *) 0 ;
  
  arg1 = (EUHICPPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EUHICPXT__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  EUHICPXTPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (EUHICPXTPtr *)new_EUHICPXTPtr__SWIG_0(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EUHICPXT__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  EUHICPXTPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (EUHICPXTPtr *)new_EUHICPXTPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EUHICPXT(void * jarg1) {
  EUHICPXTPtr *arg1 = (EUHICPXTPtr *) 0 ;
  
  arg1 = (EUHICPXTPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FRHICP__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  FRHICPPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FRHICPPtr *)new_FRHICPPtr__SWIG_0(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FRHICP__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  FRHICPPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (FRHICPPtr *)new_FRHICPPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FRHICP(void * jarg1) {
  FRHICPPtr *arg1 = (FRHICPPtr *) 0 ;
  
  arg1 = (FRHICPPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UKRPI__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  UKRPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (UKRPIPtr *)new_UKRPIPtr__SWIG_0(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UKRPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  UKRPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (UKRPIPtr *)new_UKRPIPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UKRPI(void * jarg1) {
  UKRPIPtr *arg1 = (UKRPIPtr *) 0 ;
  
  arg1 = (UKRPIPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USCPI__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  USCPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (USCPIPtr *)new_USCPIPtr__SWIG_0(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USCPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  USCPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (USCPIPtr *)new_USCPIPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_USCPI(void * jarg1) {
  USCPIPtr *arg1 = (USCPIPtr *) 0 ;
  
  arg1 = (USCPIPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZACPI__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  ZACPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZACPIPtr *)new_ZACPIPtr__SWIG_0(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZACPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  ZACPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (ZACPIPtr *)new_ZACPIPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZACPI(void * jarg1) {
  ZACPIPtr *arg1 = (ZACPIPtr *) 0 ;
  
  arg1 = (ZACPIPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYEUHICP__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYEUHICPPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYEUHICPPtr *)new_YYEUHICPPtr__SWIG_0(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYEUHICP__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYEUHICPPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYEUHICPPtr *)new_YYEUHICPPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYEUHICP(void * jarg1) {
  YYEUHICPPtr *arg1 = (YYEUHICPPtr *) 0 ;
  
  arg1 = (YYEUHICPPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYEUHICPXT__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYEUHICPXTPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYEUHICPXTPtr *)new_YYEUHICPXTPtr__SWIG_0(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYEUHICPXT__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYEUHICPXTPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYEUHICPXTPtr *)new_YYEUHICPXTPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYEUHICPXT(void * jarg1) {
  YYEUHICPXTPtr *arg1 = (YYEUHICPXTPtr *) 0 ;
  
  arg1 = (YYEUHICPXTPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYFRHICP__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYFRHICPPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYFRHICPPtr *)new_YYFRHICPPtr__SWIG_0(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYFRHICP__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYFRHICPPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYFRHICPPtr *)new_YYFRHICPPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYFRHICP(void * jarg1) {
  YYFRHICPPtr *arg1 = (YYFRHICPPtr *) 0 ;
  
  arg1 = (YYFRHICPPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUKRPI__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYUKRPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYUKRPIPtr *)new_YYUKRPIPtr__SWIG_0(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUKRPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYUKRPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYUKRPIPtr *)new_YYUKRPIPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYUKRPI(void * jarg1) {
  YYUKRPIPtr *arg1 = (YYUKRPIPtr *) 0 ;
  
  arg1 = (YYUKRPIPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUSCPI__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYUSCPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYUSCPIPtr *)new_YYUSCPIPtr__SWIG_0(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUSCPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYUSCPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYUSCPIPtr *)new_YYUSCPIPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYUSCPI(void * jarg1) {
  YYUSCPIPtr *arg1 = (YYUSCPIPtr *) 0 ;
  
  arg1 = (YYUSCPIPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYZACPI__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYZACPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYZACPIPtr *)new_YYZACPIPtr__SWIG_0(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYZACPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYZACPIPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYZACPIPtr *)new_YYZACPIPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYZACPI(void * jarg1) {
  YYZACPIPtr *arg1 = (YYZACPIPtr *) 0 ;
  
  arg1 = (YYZACPIPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPI() {
  void * jresult ;
  CPI *result = 0 ;
  
  {
    try {
      result = (CPI *)new CPI();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CPI(void * jarg1) {
  CPI *arg1 = (CPI *) 0 ;
  
  arg1 = (CPI *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelper___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ZeroHelper > *arg1 = (boost::shared_ptr< ZeroHelper > *) 0 ;
  ZeroHelper *result = 0 ;
  
  arg1 = (boost::shared_ptr< ZeroHelper > *)jarg1; 
  {
    try {
      result = (ZeroHelper *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroHelper_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< ZeroHelper > *arg1 = (boost::shared_ptr< ZeroHelper > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< ZeroHelper > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_ZeroHelper_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroHelper() {
  void * jresult ;
  boost::shared_ptr< ZeroHelper > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< ZeroHelper > *)new boost::shared_ptr< ZeroHelper >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroHelper(void * jarg1) {
  boost::shared_ptr< ZeroHelper > *arg1 = (boost::shared_ptr< ZeroHelper > *) 0 ;
  
  arg1 = (boost::shared_ptr< ZeroHelper > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelper___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YoYHelper > *arg1 = (boost::shared_ptr< YoYHelper > *) 0 ;
  YoYHelper *result = 0 ;
  
  arg1 = (boost::shared_ptr< YoYHelper > *)jarg1; 
  {
    try {
      result = (YoYHelper *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYHelper_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< YoYHelper > *arg1 = (boost::shared_ptr< YoYHelper > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< YoYHelper > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_YoYHelper_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYHelper() {
  void * jresult ;
  boost::shared_ptr< YoYHelper > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< YoYHelper > *)new boost::shared_ptr< YoYHelper >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYHelper(void * jarg1) {
  boost::shared_ptr< YoYHelper > *arg1 = (boost::shared_ptr< YoYHelper > *) 0 ;
  
  arg1 = (boost::shared_ptr< YoYHelper > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  boost::shared_ptr< ZeroHelper > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< ZeroHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< ZeroHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  std::vector< boost::shared_ptr< ZeroHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< ZeroHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  std::vector< boost::shared_ptr< ZeroHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< ZeroHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  std::vector< boost::shared_ptr< ZeroHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< ZeroHelper > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroHelperVector__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< ZeroHelper > > *)new std::vector< boost::shared_ptr< ZeroHelper > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroHelperVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< ZeroHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< ZeroHelper > > *)new std::vector< boost::shared_ptr< ZeroHelper > >((std::vector< boost::shared_ptr< ZeroHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< ZeroHelper > > *)new_std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< ZeroHelper > result;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< ZeroHelper >((const boost::shared_ptr< ZeroHelper > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< ZeroHelper > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< ZeroHelper > *) &std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< ZeroHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< ZeroHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< ZeroHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< ZeroHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< ZeroHelper > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< ZeroHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< ZeroHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< ZeroHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< ZeroHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< ZeroHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< ZeroHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< ZeroHelper > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< ZeroHelper > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroHelper > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< ZeroHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Repeat((boost::shared_ptr< ZeroHelper > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< ZeroHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< ZeroHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  boost::shared_ptr< ZeroHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< ZeroHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Contains(arg1,(boost::shared_ptr< ZeroHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  boost::shared_ptr< ZeroHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< ZeroHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< ZeroHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  boost::shared_ptr< ZeroHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< ZeroHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< ZeroHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  boost::shared_ptr< ZeroHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< ZeroHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ZeroHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_ZeroHelper_Sg__Sg__Remove(arg1,(boost::shared_ptr< ZeroHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroHelperVector(void * jarg1) {
  std::vector< boost::shared_ptr< ZeroHelper > > *arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  boost::shared_ptr< YoYHelper > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< YoYHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< YoYHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  std::vector< boost::shared_ptr< YoYHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< YoYHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  std::vector< boost::shared_ptr< YoYHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< YoYHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  std::vector< boost::shared_ptr< YoYHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< YoYHelper > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYHelperVector__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< YoYHelper > > *)new std::vector< boost::shared_ptr< YoYHelper > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYHelperVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< YoYHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< YoYHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< YoYHelper > > *)new std::vector< boost::shared_ptr< YoYHelper > >((std::vector< boost::shared_ptr< YoYHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< YoYHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< YoYHelper > > *)new_std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< YoYHelper > result;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< YoYHelper >((const boost::shared_ptr< YoYHelper > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< YoYHelper > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< YoYHelper > *) &std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< YoYHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< YoYHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< YoYHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< YoYHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< YoYHelper > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< YoYHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< YoYHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< YoYHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< YoYHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< YoYHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< YoYHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< YoYHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< YoYHelper > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< YoYHelper > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< YoYHelper > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYHelper > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< YoYHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Repeat((boost::shared_ptr< YoYHelper > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< YoYHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< YoYHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  boost::shared_ptr< YoYHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< YoYHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Contains(arg1,(boost::shared_ptr< YoYHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  boost::shared_ptr< YoYHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< YoYHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< YoYHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  boost::shared_ptr< YoYHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< YoYHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< YoYHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  boost::shared_ptr< YoYHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< YoYHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YoYHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_YoYHelper_Sg__Sg__Remove(arg1,(boost::shared_ptr< YoYHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYHelperVector(void * jarg1) {
  std::vector< boost::shared_ptr< YoYHelper > > *arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponInflationSwapHelper(double jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Date *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ZeroInflationIndexPtr *arg7 = 0 ;
  ZeroCouponInflationSwapHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (ZeroInflationIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponInflationSwapHelperPtr *)new_ZeroCouponInflationSwapHelperPtr(arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(ZeroInflationIndexPtr const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroCouponInflationSwapHelper(void * jarg1) {
  ZeroCouponInflationSwapHelperPtr *arg1 = (ZeroCouponInflationSwapHelperPtr *) 0 ;
  
  arg1 = (ZeroCouponInflationSwapHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YearOnYearInflationSwapHelper(double jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Date *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  YoYInflationIndexPtr *arg7 = 0 ;
  YearOnYearInflationSwapHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (YoYInflationIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YoYInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YearOnYearInflationSwapHelperPtr *)new_YearOnYearInflationSwapHelperPtr(arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(YoYInflationIndexPtr const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YearOnYearInflationSwapHelper(void * jarg1) {
  YearOnYearInflationSwapHelperPtr *arg1 = (YearOnYearInflationSwapHelperPtr *) 0 ;
  
  arg1 = (YearOnYearInflationSwapHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroInflation__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, unsigned int jarg6, double jarg7, void * jarg8, void * jarg9, double jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg9 = 0 ;
  Real arg10 ;
  Linear *arg11 = 0 ;
  PiecewiseZeroInflationPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< ZeroHelper > > const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Linear *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseZeroInflationPtr *)new_PiecewiseZeroInflationPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(Handle< YieldTermStructure > const &)*arg8,(std::vector< boost::shared_ptr< ZeroHelper > > const &)*arg9,arg10,(Linear const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroInflation__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, unsigned int jarg6, double jarg7, void * jarg8, void * jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg9 = 0 ;
  Real arg10 ;
  PiecewiseZeroInflationPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< ZeroHelper > > const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (PiecewiseZeroInflationPtr *)new_PiecewiseZeroInflationPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(Handle< YieldTermStructure > const &)*arg8,(std::vector< boost::shared_ptr< ZeroHelper > > const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroInflation__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, unsigned int jarg6, double jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  std::vector< boost::shared_ptr< ZeroHelper > > *arg9 = 0 ;
  PiecewiseZeroInflationPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< boost::shared_ptr< ZeroHelper > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< ZeroHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseZeroInflationPtr *)new_PiecewiseZeroInflationPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(Handle< YieldTermStructure > const &)*arg8,(std::vector< boost::shared_ptr< ZeroHelper > > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseZeroInflation_dates(void * jarg1) {
  void * jresult ;
  PiecewiseZeroInflationPtr *arg1 = (PiecewiseZeroInflationPtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (PiecewiseZeroInflationPtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &PiecewiseZeroInflationPtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseZeroInflation_times(void * jarg1) {
  void * jresult ;
  PiecewiseZeroInflationPtr *arg1 = (PiecewiseZeroInflationPtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (PiecewiseZeroInflationPtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &PiecewiseZeroInflationPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseZeroInflation_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseZeroInflationPtr *arg1 = (PiecewiseZeroInflationPtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (PiecewiseZeroInflationPtr *)jarg1; 
  {
    try {
      result = PiecewiseZeroInflationPtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseZeroInflation(void * jarg1) {
  PiecewiseZeroInflationPtr *arg1 = (PiecewiseZeroInflationPtr *) 0 ;
  
  arg1 = (PiecewiseZeroInflationPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseYoYInflation__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, unsigned int jarg6, double jarg7, void * jarg8, void * jarg9, double jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg9 = 0 ;
  Real arg10 ;
  Linear *arg11 = 0 ;
  PiecewiseYoYInflationPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< YoYHelper > > const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Linear *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseYoYInflationPtr *)new_PiecewiseYoYInflationPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(Handle< YieldTermStructure > const &)*arg8,(std::vector< boost::shared_ptr< YoYHelper > > const &)*arg9,arg10,(Linear const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseYoYInflation__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, unsigned int jarg6, double jarg7, void * jarg8, void * jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg9 = 0 ;
  Real arg10 ;
  PiecewiseYoYInflationPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< YoYHelper > > const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (PiecewiseYoYInflationPtr *)new_PiecewiseYoYInflationPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(Handle< YieldTermStructure > const &)*arg8,(std::vector< boost::shared_ptr< YoYHelper > > const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseYoYInflation__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, unsigned int jarg6, double jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  std::vector< boost::shared_ptr< YoYHelper > > *arg9 = 0 ;
  PiecewiseYoYInflationPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< boost::shared_ptr< YoYHelper > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< YoYHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseYoYInflationPtr *)new_PiecewiseYoYInflationPtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(Handle< YieldTermStructure > const &)*arg8,(std::vector< boost::shared_ptr< YoYHelper > > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseYoYInflation_dates(void * jarg1) {
  void * jresult ;
  PiecewiseYoYInflationPtr *arg1 = (PiecewiseYoYInflationPtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (PiecewiseYoYInflationPtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &PiecewiseYoYInflationPtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseYoYInflation_times(void * jarg1) {
  void * jresult ;
  PiecewiseYoYInflationPtr *arg1 = (PiecewiseYoYInflationPtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (PiecewiseYoYInflationPtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &PiecewiseYoYInflationPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseYoYInflation_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseYoYInflationPtr *arg1 = (PiecewiseYoYInflationPtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (PiecewiseYoYInflationPtr *)jarg1; 
  {
    try {
      result = PiecewiseYoYInflationPtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseYoYInflation(void * jarg1) {
  PiecewiseYoYInflationPtr *arg1 = (PiecewiseYoYInflationPtr *) 0 ;
  
  arg1 = (PiecewiseYoYInflationPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_inflationBaseDate(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  bool arg4 ;
  Date result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Frequency)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = inflationBaseDate((Date const &)*arg1,(Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__ZeroCouponInflationSwap(void * jarg1) {
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  
  arg1 = (ZeroCouponInflationSwap *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_Receiver_get() {
  int jresult ;
  enum ZeroCouponInflationSwap::Type result;
  
  result = (enum ZeroCouponInflationSwap::Type)ZeroCouponInflationSwap::Receiver;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_Payer_get() {
  int jresult ;
  enum ZeroCouponInflationSwap::Type result;
  
  result = (enum ZeroCouponInflationSwap::Type)ZeroCouponInflationSwap::Payer;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponInflationSwap__SWIG_0(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, double jarg8, void * jarg9, void * jarg10, unsigned int jarg11, void * jarg12, int jarg13) {
  void * jresult ;
  ZeroCouponInflationSwap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ZeroInflationIndexPtr *arg9 = 0 ;
  Period *arg10 = 0 ;
  bool arg11 ;
  SwigValueWrapper< Calendar > arg12 ;
  BusinessDayConvention arg13 ;
  Calendar *argp12 ;
  ZeroCouponInflationSwapPtr *result = 0 ;
  
  arg1 = (ZeroCouponInflationSwap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = (ZeroInflationIndexPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  argp12 = (Calendar *)jarg12; 
  if (!argp12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg12 = *argp12; 
  arg13 = (BusinessDayConvention)jarg13; 
  {
    try {
      result = (ZeroCouponInflationSwapPtr *)new_ZeroCouponInflationSwapPtr__SWIG_0(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ZeroInflationIndexPtr const &)*arg9,(Period const &)*arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponInflationSwap__SWIG_1(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, double jarg8, void * jarg9, void * jarg10, unsigned int jarg11, void * jarg12) {
  void * jresult ;
  ZeroCouponInflationSwap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ZeroInflationIndexPtr *arg9 = 0 ;
  Period *arg10 = 0 ;
  bool arg11 ;
  SwigValueWrapper< Calendar > arg12 ;
  Calendar *argp12 ;
  ZeroCouponInflationSwapPtr *result = 0 ;
  
  arg1 = (ZeroCouponInflationSwap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = (ZeroInflationIndexPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  argp12 = (Calendar *)jarg12; 
  if (!argp12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg12 = *argp12; 
  {
    try {
      result = (ZeroCouponInflationSwapPtr *)new_ZeroCouponInflationSwapPtr__SWIG_0(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ZeroInflationIndexPtr const &)*arg9,(Period const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponInflationSwap__SWIG_2(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, double jarg8, void * jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  ZeroCouponInflationSwap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ZeroInflationIndexPtr *arg9 = 0 ;
  Period *arg10 = 0 ;
  bool arg11 ;
  ZeroCouponInflationSwapPtr *result = 0 ;
  
  arg1 = (ZeroCouponInflationSwap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = (ZeroInflationIndexPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (ZeroCouponInflationSwapPtr *)new_ZeroCouponInflationSwapPtr__SWIG_0(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ZeroInflationIndexPtr const &)*arg9,(Period const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponInflationSwap__SWIG_3(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, double jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  ZeroCouponInflationSwap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ZeroInflationIndexPtr *arg9 = 0 ;
  Period *arg10 = 0 ;
  ZeroCouponInflationSwapPtr *result = 0 ;
  
  arg1 = (ZeroCouponInflationSwap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = (ZeroInflationIndexPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponInflationSwapPtr *)new_ZeroCouponInflationSwapPtr__SWIG_0(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ZeroInflationIndexPtr const &)*arg9,(Period const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_fairRate(void * jarg1) {
  double jresult ;
  ZeroCouponInflationSwapPtr *arg1 = (ZeroCouponInflationSwapPtr *) 0 ;
  Rate result;
  
  arg1 = (ZeroCouponInflationSwapPtr *)jarg1; 
  {
    try {
      result = (Rate)ZeroCouponInflationSwapPtr_fairRate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_fixedLeg(void * jarg1) {
  void * jresult ;
  ZeroCouponInflationSwapPtr *arg1 = (ZeroCouponInflationSwapPtr *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > > result;
  
  arg1 = (ZeroCouponInflationSwapPtr *)jarg1; 
  {
    try {
      result = ZeroCouponInflationSwapPtr_fixedLeg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< boost::shared_ptr< CashFlow > >((const std::vector< boost::shared_ptr< CashFlow > > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_inflationLeg(void * jarg1) {
  void * jresult ;
  ZeroCouponInflationSwapPtr *arg1 = (ZeroCouponInflationSwapPtr *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > > result;
  
  arg1 = (ZeroCouponInflationSwapPtr *)jarg1; 
  {
    try {
      result = ZeroCouponInflationSwapPtr_inflationLeg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< boost::shared_ptr< CashFlow > >((const std::vector< boost::shared_ptr< CashFlow > > &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_type(void * jarg1) {
  int jresult ;
  ZeroCouponInflationSwapPtr *arg1 = (ZeroCouponInflationSwapPtr *) 0 ;
  ZeroCouponInflationSwap::Type result;
  
  arg1 = (ZeroCouponInflationSwapPtr *)jarg1; 
  {
    try {
      result = (ZeroCouponInflationSwap::Type)ZeroCouponInflationSwapPtr_type(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroCouponInflationSwap(void * jarg1) {
  ZeroCouponInflationSwapPtr *arg1 = (ZeroCouponInflationSwapPtr *) 0 ;
  
  arg1 = (ZeroCouponInflationSwapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__YearOnYearInflationSwap(void * jarg1) {
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  
  arg1 = (YearOnYearInflationSwap *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_Receiver_get() {
  int jresult ;
  enum YearOnYearInflationSwap::Type result;
  
  result = (enum YearOnYearInflationSwap::Type)YearOnYearInflationSwap::Receiver;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_Payer_get() {
  int jresult ;
  enum YearOnYearInflationSwap::Type result;
  
  result = (enum YearOnYearInflationSwap::Type)YearOnYearInflationSwap::Payer;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YearOnYearInflationSwap__SWIG_0(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, void * jarg10, void * jarg11, int jarg12) {
  void * jresult ;
  YearOnYearInflationSwap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  YoYInflationIndexPtr *arg7 = 0 ;
  Period *arg8 = 0 ;
  Spread arg9 ;
  DayCounter *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  YearOnYearInflationSwapPtr *result = 0 ;
  
  arg1 = (YearOnYearInflationSwap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg7 = (YoYInflationIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YoYInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg9 = (Spread)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  {
    try {
      result = (YearOnYearInflationSwapPtr *)new_YearOnYearInflationSwapPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(YoYInflationIndexPtr const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,(Calendar const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YearOnYearInflationSwap__SWIG_1(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  YearOnYearInflationSwap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  YoYInflationIndexPtr *arg7 = 0 ;
  Period *arg8 = 0 ;
  Spread arg9 ;
  DayCounter *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  YearOnYearInflationSwapPtr *result = 0 ;
  
  arg1 = (YearOnYearInflationSwap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg7 = (YoYInflationIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YoYInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg9 = (Spread)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YearOnYearInflationSwapPtr *)new_YearOnYearInflationSwapPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(YoYInflationIndexPtr const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,(Calendar const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_fairRate(void * jarg1) {
  double jresult ;
  YearOnYearInflationSwapPtr *arg1 = (YearOnYearInflationSwapPtr *) 0 ;
  Rate result;
  
  arg1 = (YearOnYearInflationSwapPtr *)jarg1; 
  {
    try {
      result = (Rate)YearOnYearInflationSwapPtr_fairRate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YearOnYearInflationSwap(void * jarg1) {
  YearOnYearInflationSwapPtr *arg1 = (YearOnYearInflationSwapPtr *) 0 ;
  
  arg1 = (YearOnYearInflationSwapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationCapFloor_impliedVolatility__SWIG_0(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned long jarg6, double jarg7, double jarg8) {
  double jresult ;
  YoYInflationCapFloorPtr *arg1 = (YoYInflationCapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  Volatility result;
  
  arg1 = (YoYInflationCapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  {
    try {
      result = (Volatility)YoYInflationCapFloorPtr_impliedVolatility__SWIG_0((YoYInflationCapFloorPtr const *)arg1,arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationCapFloor_impliedVolatility__SWIG_1(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned long jarg6, double jarg7) {
  double jresult ;
  YoYInflationCapFloorPtr *arg1 = (YoYInflationCapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  Volatility result;
  
  arg1 = (YoYInflationCapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)YoYInflationCapFloorPtr_impliedVolatility__SWIG_0((YoYInflationCapFloorPtr const *)arg1,arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationCapFloor_impliedVolatility__SWIG_2(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned long jarg6) {
  double jresult ;
  YoYInflationCapFloorPtr *arg1 = (YoYInflationCapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  Volatility result;
  
  arg1 = (YoYInflationCapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (Volatility)YoYInflationCapFloorPtr_impliedVolatility__SWIG_0((YoYInflationCapFloorPtr const *)arg1,arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationCapFloor_impliedVolatility__SWIG_3(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5) {
  double jresult ;
  YoYInflationCapFloorPtr *arg1 = (YoYInflationCapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Volatility result;
  
  arg1 = (YoYInflationCapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Volatility)YoYInflationCapFloorPtr_impliedVolatility__SWIG_0((YoYInflationCapFloorPtr const *)arg1,arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationCapFloor_impliedVolatility__SWIG_4(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  double jresult ;
  YoYInflationCapFloorPtr *arg1 = (YoYInflationCapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Volatility result;
  
  arg1 = (YoYInflationCapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  {
    try {
      result = (Volatility)YoYInflationCapFloorPtr_impliedVolatility__SWIG_0((YoYInflationCapFloorPtr const *)arg1,arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCapFloor() {
  void * jresult ;
  YoYInflationCapFloorPtr *result = 0 ;
  
  {
    try {
      result = (YoYInflationCapFloorPtr *)new YoYInflationCapFloorPtr();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCapFloor(void * jarg1) {
  YoYInflationCapFloorPtr *arg1 = (YoYInflationCapFloorPtr *) 0 ;
  
  arg1 = (YoYInflationCapFloorPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCap(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  YoYInflationCapPtr *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCapPtr *)new_YoYInflationCapPtr((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCap(void * jarg1) {
  YoYInflationCapPtr *arg1 = (YoYInflationCapPtr *) 0 ;
  
  arg1 = (YoYInflationCapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationFloor(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  YoYInflationFloorPtr *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationFloorPtr *)new_YoYInflationFloorPtr((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationFloor(void * jarg1) {
  YoYInflationFloorPtr *arg1 = (YoYInflationFloorPtr *) 0 ;
  
  arg1 = (YoYInflationFloorPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCollar(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  YoYInflationCollarPtr *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCollarPtr *)new_YoYInflationCollarPtr((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCollar(void * jarg1) {
  YoYInflationCollarPtr *arg1 = (YoYInflationCollarPtr *) 0 ;
  
  arg1 = (YoYInflationCollarPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ShortRateModel___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  ShortRateModel *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  {
    try {
      result = (ShortRateModel *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ShortRateModel_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_ShortRateModel_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ShortRateModel_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_ShortRateModel_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ShortRateModel() {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< ShortRateModel > *)new boost::shared_ptr< ShortRateModel >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ShortRateModel(void * jarg1) {
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ShortRateModel_parameters(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  Array result;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  {
    try {
      result = (*arg1)->params();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModel_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< bool > *arg7 = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real > const &)*arg6,(std::vector< bool > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModel_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModel_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModel_calibrate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ShortRateModel_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ShortRateModel_endCriteria(void * jarg1) {
  int jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  EndCriteria::Type result;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  {
    try {
      result = (EndCriteria::Type)(*arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModel_setParams(void * jarg1, void * jarg2) {
  boost::shared_ptr< ShortRateModel > *arg1 = (boost::shared_ptr< ShortRateModel > *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ShortRateModelHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Handle< ShortRateModel > *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< ShortRateModel > *)new Handle< ShortRateModel >((boost::shared_ptr< ShortRateModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ShortRateModelHandle__SWIG_1() {
  void * jresult ;
  Handle< ShortRateModel > *result = 0 ;
  
  {
    try {
      result = (Handle< ShortRateModel > *)new Handle< ShortRateModel >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  boost::shared_ptr< ShortRateModel > result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< ShortRateModel >((const boost::shared_ptr< ShortRateModel > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  bool result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = Handle_Sl_ShortRateModel_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ShortRateModelHandle(void * jarg1) {
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_parameters(void * jarg1) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Array result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = (*arg1)->params();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< bool > *arg7 = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real > const &)*arg6,(std::vector< bool > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_calibrate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  Real result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_endCriteria(void * jarg1) {
  int jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  EndCriteria::Type result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = (EndCriteria::Type)(*arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_setParams(void * jarg1, void * jarg2) {
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableShortRateModelHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  RelinkableHandle< ShortRateModel > *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< ShortRateModel > *)new RelinkableHandle< ShortRateModel >((boost::shared_ptr< ShortRateModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableShortRateModelHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< ShortRateModel > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< ShortRateModel > *)new RelinkableHandle< ShortRateModel >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableShortRateModelHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< ShortRateModel > *arg1 = (RelinkableHandle< ShortRateModel > *) 0 ;
  boost::shared_ptr< ShortRateModel > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< ShortRateModel > *)jarg1; 
  arg2 = (boost::shared_ptr< ShortRateModel > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< ShortRateModel > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableShortRateModelHandle(void * jarg1) {
  RelinkableHandle< ShortRateModel > *arg1 = (RelinkableHandle< ShortRateModel > *) 0 ;
  
  arg1 = (RelinkableHandle< ShortRateModel > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Vasicek__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  VasicekPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (VasicekPtr *)new_VasicekPtr__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Vasicek__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  VasicekPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (VasicekPtr *)new_VasicekPtr__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Vasicek__SWIG_2(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  VasicekPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (VasicekPtr *)new_VasicekPtr__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Vasicek__SWIG_3(double jarg1, double jarg2) {
  void * jresult ;
  Rate arg1 ;
  Real arg2 ;
  VasicekPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (VasicekPtr *)new_VasicekPtr__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Vasicek__SWIG_4(double jarg1) {
  void * jresult ;
  Rate arg1 ;
  VasicekPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  {
    try {
      result = (VasicekPtr *)new_VasicekPtr__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Vasicek__SWIG_5() {
  void * jresult ;
  VasicekPtr *result = 0 ;
  
  {
    try {
      result = (VasicekPtr *)new_VasicekPtr__SWIG_0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Vasicek_discount(void * jarg1, double jarg2) {
  double jresult ;
  VasicekPtr *arg1 = (VasicekPtr *) 0 ;
  Time arg2 ;
  DiscountFactor result;
  
  arg1 = (VasicekPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)VasicekPtr_discount((VasicekPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Vasicek_discountBond(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  VasicekPtr *arg1 = (VasicekPtr *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  Real result;
  
  arg1 = (VasicekPtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)VasicekPtr_discountBond((VasicekPtr const *)arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Vasicek(void * jarg1) {
  VasicekPtr *arg1 = (VasicekPtr *) 0 ;
  
  arg1 = (VasicekPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HullWhite__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  HullWhitePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (HullWhitePtr *)new_HullWhitePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HullWhite__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  HullWhitePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (HullWhitePtr *)new_HullWhitePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HullWhite__SWIG_2(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  HullWhitePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (HullWhitePtr *)new_HullWhitePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HullWhite_discount(void * jarg1, double jarg2) {
  double jresult ;
  HullWhitePtr *arg1 = (HullWhitePtr *) 0 ;
  Time arg2 ;
  DiscountFactor result;
  
  arg1 = (HullWhitePtr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)HullWhitePtr_discount((HullWhitePtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HullWhite_discountBond(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  HullWhitePtr *arg1 = (HullWhitePtr *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  Real result;
  
  arg1 = (HullWhitePtr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)HullWhitePtr_discountBond((HullWhitePtr const *)arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HullWhite_convexityBias(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  Real arg1 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Rate result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Rate)HullWhitePtr_convexityBias(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HullWhite(void * jarg1) {
  HullWhitePtr *arg1 = (HullWhitePtr *) 0 ;
  
  arg1 = (HullWhitePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackKarasinski__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  BlackKarasinskiPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (BlackKarasinskiPtr *)new_BlackKarasinskiPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackKarasinski__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  BlackKarasinskiPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (BlackKarasinskiPtr *)new_BlackKarasinskiPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackKarasinski__SWIG_2(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  BlackKarasinskiPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackKarasinskiPtr *)new_BlackKarasinskiPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackKarasinski(void * jarg1) {
  BlackKarasinskiPtr *arg1 = (BlackKarasinskiPtr *) 0 ;
  
  arg1 = (BlackKarasinskiPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  G2Ptr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (G2Ptr *)new_G2Ptr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  G2Ptr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (G2Ptr *)new_G2Ptr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  G2Ptr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (G2Ptr *)new_G2Ptr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  G2Ptr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (G2Ptr *)new_G2Ptr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2__SWIG_4(void * jarg1, double jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  G2Ptr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (G2Ptr *)new_G2Ptr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2__SWIG_5(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  G2Ptr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (G2Ptr *)new_G2Ptr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_G2_discount(void * jarg1, double jarg2) {
  double jresult ;
  G2Ptr *arg1 = (G2Ptr *) 0 ;
  Time arg2 ;
  DiscountFactor result;
  
  arg1 = (G2Ptr *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)G2Ptr_discount((G2Ptr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_G2_discountBond(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  G2Ptr *arg1 = (G2Ptr *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  Rate arg5 ;
  Real result;
  
  arg1 = (G2Ptr *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Rate)jarg5; 
  {
    try {
      result = (Real)G2Ptr_discountBond((G2Ptr const *)arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_G2(void * jarg1) {
  G2Ptr *arg1 = (G2Ptr *) 0 ;
  
  arg1 = (G2Ptr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JamshidianSwaptionEngine__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  JamshidianSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (JamshidianSwaptionEnginePtr *)new_JamshidianSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JamshidianSwaptionEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  JamshidianSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (JamshidianSwaptionEnginePtr *)new_JamshidianSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JamshidianSwaptionEngine(void * jarg1) {
  JamshidianSwaptionEnginePtr *arg1 = (JamshidianSwaptionEnginePtr *) 0 ;
  
  arg1 = (JamshidianSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  TreeSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeSwaptionEnginePtr *)new_TreeSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  TreeSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TreeSwaptionEnginePtr *)new_TreeSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  TreeSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeSwaptionEnginePtr *)new_TreeSwaptionEnginePtr__SWIG_2((boost::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  TreeSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeSwaptionEnginePtr *)new_TreeSwaptionEnginePtr__SWIG_2((boost::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_4(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  TreeSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeSwaptionEnginePtr *)new_TreeSwaptionEnginePtr__SWIG_4((Handle< ShortRateModel > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_5(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  TreeSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TreeSwaptionEnginePtr *)new_TreeSwaptionEnginePtr__SWIG_4((Handle< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TreeSwaptionEngine(void * jarg1) {
  TreeSwaptionEnginePtr *arg1 = (TreeSwaptionEnginePtr *) 0 ;
  
  arg1 = (TreeSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticCapFloorEngine__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  AnalyticCapFloorEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticCapFloorEnginePtr *)new_AnalyticCapFloorEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticCapFloorEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  AnalyticCapFloorEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticCapFloorEnginePtr *)new_AnalyticCapFloorEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticCapFloorEngine(void * jarg1) {
  AnalyticCapFloorEnginePtr *arg1 = (AnalyticCapFloorEnginePtr *) 0 ;
  
  arg1 = (AnalyticCapFloorEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCapFloorEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  TreeCapFloorEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCapFloorEnginePtr *)new_TreeCapFloorEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCapFloorEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  TreeCapFloorEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TreeCapFloorEnginePtr *)new_TreeCapFloorEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCapFloorEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  TreeCapFloorEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCapFloorEnginePtr *)new_TreeCapFloorEnginePtr__SWIG_2((boost::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCapFloorEngine__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  TreeCapFloorEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCapFloorEnginePtr *)new_TreeCapFloorEnginePtr__SWIG_2((boost::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TreeCapFloorEngine(void * jarg1) {
  TreeCapFloorEnginePtr *arg1 = (TreeCapFloorEnginePtr *) 0 ;
  
  arg1 = (TreeCapFloorEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2SwaptionEngine(void * jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  G2SwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (G2SwaptionEnginePtr *)new_G2SwaptionEnginePtr((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_G2SwaptionEngine(void * jarg1) {
  G2SwaptionEnginePtr *arg1 = (G2SwaptionEnginePtr *) 0 ;
  
  arg1 = (G2SwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  FdG2SwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdG2SwaptionEnginePtr *)new_FdG2SwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, double jarg6) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  FdG2SwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FdG2SwaptionEnginePtr *)new_FdG2SwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdG2SwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdG2SwaptionEnginePtr *)new_FdG2SwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdG2SwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdG2SwaptionEnginePtr *)new_FdG2SwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FdG2SwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdG2SwaptionEnginePtr *)new_FdG2SwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_5(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  FdG2SwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdG2SwaptionEnginePtr *)new_FdG2SwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  FdG2SwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdG2SwaptionEnginePtr *)new_FdG2SwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdG2SwaptionEngine(void * jarg1) {
  FdG2SwaptionEnginePtr *arg1 = (FdG2SwaptionEnginePtr *) 0 ;
  
  arg1 = (FdG2SwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, double jarg5, void * jarg6) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Real arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  FdHullWhiteSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHullWhiteSwaptionEnginePtr *)new_FdHullWhiteSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, double jarg5) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Real arg5 ;
  FdHullWhiteSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FdHullWhiteSwaptionEnginePtr *)new_FdHullWhiteSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdHullWhiteSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHullWhiteSwaptionEnginePtr *)new_FdHullWhiteSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FdHullWhiteSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHullWhiteSwaptionEnginePtr *)new_FdHullWhiteSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_4(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  FdHullWhiteSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdHullWhiteSwaptionEnginePtr *)new_FdHullWhiteSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_5(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  FdHullWhiteSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHullWhiteSwaptionEnginePtr *)new_FdHullWhiteSwaptionEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdHullWhiteSwaptionEngine(void * jarg1) {
  FdHullWhiteSwaptionEnginePtr *arg1 = (FdHullWhiteSwaptionEnginePtr *) 0 ;
  
  arg1 = (FdHullWhiteSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bond__SWIG_0(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Leg *arg6 = 0 ;
  BondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Leg *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BondPtr *)new_BondPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(std::vector< boost::shared_ptr< CashFlow > > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bond__SWIG_1(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  BondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BondPtr *)new_BondPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bond__SWIG_2(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  BondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BondPtr *)new_BondPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_nextCouponRate__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date *arg2 = 0 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)BondPtr_nextCouponRate__SWIG_0(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_nextCouponRate__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = (Rate)BondPtr_nextCouponRate__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_previousCouponRate__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date *arg2 = 0 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)BondPtr_previousCouponRate__SWIG_0(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_previousCouponRate__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = (Rate)BondPtr_previousCouponRate__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Bond_settlementDays(void * jarg1) {
  unsigned int jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Natural result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = (Natural)BondPtr_settlementDays((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_settlementDate__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1; 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = BondPtr_settlementDate__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_settlementDate__SWIG_1(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_settlementDate__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_startDate(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_startDate((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_maturityDate(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_maturityDate((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_issueDate(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_issueDate((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_cashflows(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > > result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_cashflows((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< boost::shared_ptr< CashFlow > >((const std::vector< boost::shared_ptr< CashFlow > > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_redemptions(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > > result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_redemptions((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< boost::shared_ptr< CashFlow > >((const std::vector< boost::shared_ptr< CashFlow > > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_redemption(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  boost::shared_ptr< CashFlow > result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_redemption((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< CashFlow >((const boost::shared_ptr< CashFlow > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_calendar(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_calendar((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_notionals(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  std::vector< Real > result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = BondPtr_notionals((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_notional__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date arg2 ;
  Date *argp2 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Real)BondPtr_notional__SWIG_0((BondPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_notional__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = (Real)BondPtr_notional__SWIG_0((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_cleanPrice__SWIG_0(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = (Real)BondPtr_cleanPrice__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_cleanPrice__SWIG_1(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondPtr_cleanPrice__SWIG_1(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_cleanPrice__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondPtr_cleanPrice__SWIG_1(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_dirtyPrice__SWIG_0(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = (Real)BondPtr_dirtyPrice__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_dirtyPrice__SWIG_1(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondPtr_dirtyPrice__SWIG_1(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_dirtyPrice__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondPtr_dirtyPrice__SWIG_1(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_yield__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, double jarg5, unsigned long jarg6) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Real arg5 ;
  Size arg6 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (Real)BondPtr_yield__SWIG_0(arg1,(DayCounter const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_yield__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4, double jarg5) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Real arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)BondPtr_yield__SWIG_0(arg1,(DayCounter const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_yield__SWIG_2(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (Real)BondPtr_yield__SWIG_0(arg1,(DayCounter const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_yield__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, double jarg7, unsigned long jarg8) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real arg7 ;
  Size arg8 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Size)jarg8; 
  {
    try {
      result = (Real)BondPtr_yield__SWIG_3(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_yield__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, double jarg7) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real arg7 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)BondPtr_yield__SWIG_3(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_yield__SWIG_5(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondPtr_yield__SWIG_3(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_yield__SWIG_6(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondPtr_yield__SWIG_3(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_accruedAmount__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondPtr_accruedAmount__SWIG_0(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_accruedAmount__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = (Real)BondPtr_accruedAmount__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_settlementValue__SWIG_0(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      result = (Real)BondPtr_settlementValue__SWIG_0((BondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_settlementValue__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  BondPtr *arg1 = (BondPtr *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)BondPtr_settlementValue__SWIG_1((BondPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bond(void * jarg1) {
  BondPtr *arg1 = (BondPtr *) 0 ;
  
  arg1 = (BondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_cleanPriceFromZSpread__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)cleanPriceFromZSpread((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_cleanPriceFromZSpread__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)cleanPriceFromZSpread((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponBond__SWIG_0(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  ZeroCouponBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponBondPtr *)new_ZeroCouponBondPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponBond__SWIG_1(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, double jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  ZeroCouponBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (ZeroCouponBondPtr *)new_ZeroCouponBondPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponBond__SWIG_2(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  ZeroCouponBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = (ZeroCouponBondPtr *)new_ZeroCouponBondPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponBond__SWIG_3(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  ZeroCouponBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponBondPtr *)new_ZeroCouponBondPtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroCouponBond(void * jarg1) {
  ZeroCouponBondPtr *arg1 = (ZeroCouponBondPtr *) 0 ;
  
  arg1 = (ZeroCouponBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_0(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, int jarg12, unsigned int jarg13) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date arg8 ;
  Calendar *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  bool arg13 ;
  Date *argp8 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(Calendar const &)*arg9,(Period const &)*arg10,(Calendar const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_1(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, int jarg12) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date arg8 ;
  Calendar *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  Date *argp8 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(Calendar const &)*arg9,(Period const &)*arg10,(Calendar const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_2(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date arg8 ;
  Calendar *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  Date *argp8 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(Calendar const &)*arg9,(Period const &)*arg10,(Calendar const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_3(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date arg8 ;
  Calendar *arg9 = 0 ;
  Period *arg10 = 0 ;
  Date *argp8 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(Calendar const &)*arg9,(Period const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_4(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date arg8 ;
  Calendar *arg9 = 0 ;
  Date *argp8 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(Calendar const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_5(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date arg8 ;
  Date *argp8 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_6(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_7(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_8(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_9(int jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11, unsigned int jarg12) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Period *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  bool arg12 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8,(Period const &)*arg9,(Calendar const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_10(int jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Period *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8,(Period const &)*arg9,(Calendar const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_11(int jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Period *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8,(Period const &)*arg9,(Calendar const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_12(int jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Period *arg9 = 0 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8,(Period const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_13(int jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_14(int jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4,arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_15(int jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_16(int jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBond__SWIG_17(int jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate > *arg4 = 0 ;
  FixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< InterestRate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< InterestRate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondPtr *)new_FixedRateBondPtr__SWIG_9(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_FixedRateBond_frequency(void * jarg1) {
  int jresult ;
  FixedRateBondPtr *arg1 = (FixedRateBondPtr *) 0 ;
  Frequency result;
  
  arg1 = (FixedRateBondPtr *)jarg1; 
  {
    try {
      result = (Frequency)FixedRateBondPtr_frequency((FixedRateBondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateBond_dayCounter(void * jarg1) {
  void * jresult ;
  FixedRateBondPtr *arg1 = (FixedRateBondPtr *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (FixedRateBondPtr *)jarg1; 
  {
    try {
      result = FixedRateBondPtr_dayCounter((FixedRateBondPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedRateBond(void * jarg1) {
  FixedRateBondPtr *arg1 = (FixedRateBondPtr *) 0 ;
  
  arg1 = (FixedRateBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_0(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, double jarg13, void * jarg14) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  bool arg12 ;
  Real arg13 ;
  Date *arg14 = 0 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,arg12,arg13,(Date const &)*arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_1(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, double jarg13) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  bool arg12 ;
  Real arg13 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_2(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  bool arg12 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_3(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_4(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_5(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_6(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_7(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_8(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_9(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  IborIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  FloatingRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (IborIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBondPtr *)new_FloatingRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(IborIndexPtr const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloatingRateBond(void * jarg1) {
  FloatingRateBondPtr *arg1 = (FloatingRateBondPtr *) 0 ;
  
  arg1 = (FloatingRateBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsRateBond__SWIG_0(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, double jarg13, void * jarg14) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  SwapIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  bool arg12 ;
  Real arg13 ;
  Date *arg14 = 0 ;
  CmsRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (SwapIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Natural)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsRateBondPtr *)new_CmsRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(SwapIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,arg12,arg13,(Date const &)*arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsRateBond__SWIG_1(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, double jarg13) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  SwapIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  bool arg12 ;
  Real arg13 ;
  CmsRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (SwapIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Natural)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (CmsRateBondPtr *)new_CmsRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(SwapIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsRateBond__SWIG_2(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  SwapIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  bool arg12 ;
  CmsRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (SwapIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Natural)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (CmsRateBondPtr *)new_CmsRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(SwapIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsRateBond__SWIG_3(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  SwapIndexPtr *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  CmsRateBondPtr *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (SwapIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Natural)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsRateBondPtr *)new_CmsRateBondPtr__SWIG_0(arg1,arg2,(Schedule const &)*arg3,(SwapIndexPtr const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CmsRateBond(void * jarg1) {
  CmsRateBondPtr *arg1 = (CmsRateBondPtr *) 0 ;
  
  arg1 = (CmsRateBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingBondEngine(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  DiscountingBondEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingBondEnginePtr *)new_DiscountingBondEnginePtr((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DiscountingBondEngine(void * jarg1) {
  DiscountingBondEnginePtr *arg1 = (DiscountingBondEnginePtr *) 0 ;
  
  arg1 = (DiscountingBondEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableFixedRateBond(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date arg8 ;
  std::vector< boost::shared_ptr< Callability > > *arg9 = 0 ;
  Date *argp8 ;
  CallableFixedRateBondPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  argp8 = (Date *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (std::vector< boost::shared_ptr< Callability > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CallableFixedRateBondPtr *)new_CallableFixedRateBondPtr(arg1,arg2,(Schedule const &)*arg3,(std::vector< double > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(std::vector< boost::shared_ptr< Callability > > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_OAS__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, unsigned long jarg9, double jarg10) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Size arg9 ;
  Spread arg10 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = (Spread)jarg10; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_OAS__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_OAS__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, unsigned long jarg9) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Size arg9 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_OAS__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_OAS__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_OAS__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_OAS__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_OAS__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_OAS__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_OAS__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_cleanPriceOAS__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_cleanPriceOAS__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_cleanPriceOAS__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_cleanPriceOAS__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_effectiveDuration__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, double jarg7) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real arg7 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_effectiveDuration__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_effectiveDuration__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_effectiveDuration__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_effectiveConvexity__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, double jarg7) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real arg7 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_effectiveConvexity__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_effectiveConvexity__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real result;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)CallableFixedRateBondPtr_effectiveConvexity__SWIG_0(arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CallableFixedRateBond(void * jarg1) {
  CallableFixedRateBondPtr *arg1 = (CallableFixedRateBondPtr *) 0 ;
  
  arg1 = (CallableFixedRateBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCallableFixedRateBondEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  TreeCallableFixedRateBondEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCallableFixedRateBondEnginePtr *)new_TreeCallableFixedRateBondEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCallableFixedRateBondEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  TreeCallableFixedRateBondEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TreeCallableFixedRateBondEnginePtr *)new_TreeCallableFixedRateBondEnginePtr__SWIG_0((boost::shared_ptr< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCallableFixedRateBondEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  TreeCallableFixedRateBondEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCallableFixedRateBondEnginePtr *)new_TreeCallableFixedRateBondEnginePtr__SWIG_2((boost::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCallableFixedRateBondEngine__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  TreeCallableFixedRateBondEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< ShortRateModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCallableFixedRateBondEnginePtr *)new_TreeCallableFixedRateBondEnginePtr__SWIG_2((boost::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TreeCallableFixedRateBondEngine(void * jarg1) {
  TreeCallableFixedRateBondEnginePtr *arg1 = (TreeCallableFixedRateBondEnginePtr *) 0 ;
  
  arg1 = (TreeCallableFixedRateBondEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCallableFixedRateBondEngine(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  BlackCallableFixedRateBondEnginePtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackCallableFixedRateBondEnginePtr *)new_BlackCallableFixedRateBondEnginePtr((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackCallableFixedRateBondEngine(void * jarg1) {
  BlackCallableFixedRateBondEnginePtr *arg1 = (BlackCallableFixedRateBondEnginePtr *) 0 ;
  
  arg1 = (BlackCallableFixedRateBondEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPIBond__SWIG_0(unsigned int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15, int jarg16, unsigned int jarg17) {
  void * jresult ;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ZeroInflationIndexPtr *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  Date *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  BusinessDayConvention arg16 ;
  bool arg17 ;
  CPIBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (ZeroInflationIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg16 = (BusinessDayConvention)jarg16; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (CPIBondPtr *)new_CPIBondPtr__SWIG_0(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ZeroInflationIndexPtr const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< double > const &)*arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Calendar const &)*arg13,(Period const &)*arg14,(Calendar const &)*arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPIBond__SWIG_1(unsigned int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15, int jarg16) {
  void * jresult ;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ZeroInflationIndexPtr *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  Date *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  BusinessDayConvention arg16 ;
  CPIBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (ZeroInflationIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg16 = (BusinessDayConvention)jarg16; 
  {
    try {
      result = (CPIBondPtr *)new_CPIBondPtr__SWIG_0(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ZeroInflationIndexPtr const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< double > const &)*arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Calendar const &)*arg13,(Period const &)*arg14,(Calendar const &)*arg15,arg16);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPIBond__SWIG_2(unsigned int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15) {
  void * jresult ;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ZeroInflationIndexPtr *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  Date *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  CPIBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (ZeroInflationIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBondPtr *)new_CPIBondPtr__SWIG_0(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ZeroInflationIndexPtr const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< double > const &)*arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Calendar const &)*arg13,(Period const &)*arg14,(Calendar const &)*arg15);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPIBond__SWIG_3(unsigned int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11, void * jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ZeroInflationIndexPtr *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  Date *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  Period *arg14 = 0 ;
  CPIBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (ZeroInflationIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBondPtr *)new_CPIBondPtr__SWIG_0(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ZeroInflationIndexPtr const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< double > const &)*arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Calendar const &)*arg13,(Period const &)*arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPIBond__SWIG_4(unsigned int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ZeroInflationIndexPtr *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  Date *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  CPIBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (ZeroInflationIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBondPtr *)new_CPIBondPtr__SWIG_0(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ZeroInflationIndexPtr const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< double > const &)*arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Calendar const &)*arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPIBond__SWIG_5(unsigned int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11, void * jarg12) {
  void * jresult ;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ZeroInflationIndexPtr *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  Date *arg12 = 0 ;
  CPIBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (ZeroInflationIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBondPtr *)new_CPIBondPtr__SWIG_0(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ZeroInflationIndexPtr const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< double > const &)*arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPIBond__SWIG_6(unsigned int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, int jarg11) {
  void * jresult ;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ZeroInflationIndexPtr *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  CPIBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (ZeroInflationIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  {
    try {
      result = (CPIBondPtr *)new_CPIBondPtr__SWIG_0(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ZeroInflationIndexPtr const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< double > const &)*arg9,(DayCounter const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPIBond__SWIG_7(unsigned int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ZeroInflationIndexPtr *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  CPIBondPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg6 = (ZeroInflationIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ZeroInflationIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBondPtr *)new_CPIBondPtr__SWIG_0(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ZeroInflationIndexPtr const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< double > const &)*arg9,(DayCounter const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CPIBond(void * jarg1) {
  CPIBondPtr *arg1 = (CPIBondPtr *) 0 ;
  
  arg1 = (CPIBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_startDate(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions_startDate((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_maturityDate(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions_maturityDate((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BondFunctions_isTradable__SWIG_0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  bool result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)BondFunctions_isTradable__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BondFunctions_isTradable__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  BondPtr *arg1 = 0 ;
  bool result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)BondFunctions_isTradable__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_previousCashFlowDate__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = BondFunctions_previousCashFlowDate__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_previousCashFlowDate__SWIG_1(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions_previousCashFlowDate__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_nextCashFlowDate__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = BondFunctions_nextCashFlowDate__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_nextCashFlowDate__SWIG_1(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions_nextCashFlowDate__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_previousCashFlowAmount__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Real)BondFunctions_previousCashFlowAmount__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_previousCashFlowAmount__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_previousCashFlowAmount__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_nextCashFlowAmount__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Real)BondFunctions_nextCashFlowAmount__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_nextCashFlowAmount__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_nextCashFlowAmount__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_previousCouponRate__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Rate)BondFunctions_previousCouponRate__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_previousCouponRate__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)BondFunctions_previousCouponRate__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_nextCouponRate__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Rate)BondFunctions_nextCouponRate__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_nextCouponRate__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)BondFunctions_nextCouponRate__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualStartDate__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = BondFunctions_accrualStartDate__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualStartDate__SWIG_1(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions_accrualStartDate__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualEndDate__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = BondFunctions_accrualEndDate__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualEndDate__SWIG_1(void * jarg1) {
  void * jresult ;
  BondPtr *arg1 = 0 ;
  Date result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions_accrualEndDate__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualPeriod__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Time)BondFunctions_accrualPeriod__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualPeriod__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)BondFunctions_accrualPeriod__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualDays__SWIG_0(void * jarg1, void * jarg2) {
  long jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  BigInteger result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (BigInteger)BondFunctions_accrualDays__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualDays__SWIG_1(void * jarg1) {
  long jresult ;
  BondPtr *arg1 = 0 ;
  BigInteger result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BigInteger)BondFunctions_accrualDays__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_accruedPeriod__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Time)BondFunctions_accruedPeriod__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_accruedPeriod__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)BondFunctions_accruedPeriod__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_BondFunctions_accruedDays__SWIG_0(void * jarg1, void * jarg2) {
  long jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  BigInteger result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (BigInteger)BondFunctions_accruedDays__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_QuantLib_BondFunctions_accruedDays__SWIG_1(void * jarg1) {
  long jresult ;
  BondPtr *arg1 = 0 ;
  BigInteger result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BigInteger)BondFunctions_accruedDays__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_accruedAmount__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Real)BondFunctions_accruedAmount__SWIG_0((BondPtr const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_accruedAmount__SWIG_1(void * jarg1) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_accruedAmount__SWIG_0((BondPtr const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_cleanPrice__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)BondFunctions_cleanPrice__SWIG_0((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_cleanPrice__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_cleanPrice__SWIG_0((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_bps__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)BondFunctions_bps__SWIG_0((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_bps__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_bps__SWIG_0((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_atmRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Date arg3 ;
  Real arg4 ;
  Date *argp3 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Rate)BondFunctions_atmRate__SWIG_0((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_atmRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Rate)BondFunctions_atmRate__SWIG_0((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_atmRate__SWIG_2(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)BondFunctions_atmRate__SWIG_0((BondPtr const &)*arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_cleanPrice__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)BondFunctions_cleanPrice__SWIG_2((BondPtr const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_cleanPrice__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_cleanPrice__SWIG_2((BondPtr const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_cleanPrice__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (Real)BondFunctions_cleanPrice__SWIG_4((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_cleanPrice__SWIG_5(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions_cleanPrice__SWIG_4((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_bps__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)BondFunctions_bps__SWIG_2((BondPtr const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_bps__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_bps__SWIG_2((BondPtr const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_bps__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (Real)BondFunctions_bps__SWIG_4((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_bps__SWIG_5(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions_bps__SWIG_4((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yield__SWIG_0(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, double jarg7, unsigned long jarg8, double jarg9) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  Size arg8 ;
  Rate arg9 ;
  Date *argp6 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Real)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (Rate)BondFunctions_yield__SWIG_0((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yield__SWIG_1(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, double jarg7, unsigned long jarg8) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  Size arg8 ;
  Date *argp6 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Real)jarg7; 
  arg8 = (Size)jarg8; 
  {
    try {
      result = (Rate)BondFunctions_yield__SWIG_0((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yield__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, double jarg7) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  Date *argp6 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Rate)BondFunctions_yield__SWIG_0((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yield__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (Rate)BondFunctions_yield__SWIG_0((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yield__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Rate result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Rate)BondFunctions_yield__SWIG_0((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldBrent__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, double jarg9) {
  double jresult ;
  Brent arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  Brent *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Brent *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Brent", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldBrent__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8) {
  double jresult ;
  Brent arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Brent *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Brent *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Brent", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldBrent__SWIG_2(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  Brent arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Brent *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Brent *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Brent", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldBrent__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  Brent arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Brent *argp1 ;
  Rate result;
  
  argp1 = (Brent *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Brent", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldBisection__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, double jarg9) {
  double jresult ;
  Bisection arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  Bisection *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Bisection *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Bisection", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldBisection__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8) {
  double jresult ;
  Bisection arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Bisection *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Bisection *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Bisection", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldBisection__SWIG_2(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  Bisection arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Bisection *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Bisection *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Bisection", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldBisection__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  Bisection arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Bisection *argp1 ;
  Rate result;
  
  argp1 = (Bisection *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Bisection", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldFalsePosition__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, double jarg9) {
  double jresult ;
  FalsePosition arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  FalsePosition *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (FalsePosition *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null FalsePosition", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldFalsePosition__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8) {
  double jresult ;
  FalsePosition arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  FalsePosition *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (FalsePosition *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null FalsePosition", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldFalsePosition__SWIG_2(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  FalsePosition arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  FalsePosition *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (FalsePosition *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null FalsePosition", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldFalsePosition__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  FalsePosition arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  FalsePosition *argp1 ;
  Rate result;
  
  argp1 = (FalsePosition *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null FalsePosition", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldRidder__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, double jarg9) {
  double jresult ;
  Ridder arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  Ridder *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Ridder *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Ridder", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldRidder__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8) {
  double jresult ;
  Ridder arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Ridder *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Ridder *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Ridder", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldRidder__SWIG_2(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  Ridder arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Ridder *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Ridder *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Ridder", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldRidder__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  Ridder arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Ridder *argp1 ;
  Rate result;
  
  argp1 = (Ridder *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Ridder", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldSecant__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, double jarg9) {
  double jresult ;
  Secant arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  Secant *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Secant *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Secant", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldSecant__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8) {
  double jresult ;
  Secant arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Secant *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Secant *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Secant", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldSecant__SWIG_2(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  Secant arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Secant *argp1 ;
  Date *argp7 ;
  Rate result;
  
  argp1 = (Secant *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Secant", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldSecant__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  Secant arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Secant *argp1 ;
  Rate result;
  
  argp1 = (Secant *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Secant", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_duration__SWIG_0(void * jarg1, void * jarg2, int jarg3, void * jarg4) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  Date arg4 ;
  Date *argp4 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = (Duration::Type)jarg3; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (Time)BondFunctions_duration__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_duration__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  arg3 = (Duration::Type)jarg3; 
  {
    try {
      result = (Time)BondFunctions_duration__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_duration__SWIG_2(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)BondFunctions_duration__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_duration__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Duration::Type)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Time)BondFunctions_duration__SWIG_3((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_duration__SWIG_4(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, int jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Duration::Type)jarg6; 
  {
    try {
      result = (Time)BondFunctions_duration__SWIG_3((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_duration__SWIG_5(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Time result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Time)BondFunctions_duration__SWIG_3((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_convexity__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)BondFunctions_convexity__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_convexity__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_convexity__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_convexity__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (Real)BondFunctions_convexity__SWIG_2((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_convexity__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions_convexity__SWIG_2((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_basisPointValue__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)BondFunctions_basisPointValue__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_basisPointValue__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_basisPointValue__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_basisPointValue__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (Real)BondFunctions_basisPointValue__SWIG_2((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_basisPointValue__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions_basisPointValue__SWIG_2((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldValueBasisPoint__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)BondFunctions_yieldValueBasisPoint__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldValueBasisPoint__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions_yieldValueBasisPoint__SWIG_0((BondPtr const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldValueBasisPoint__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (Real)BondFunctions_yieldValueBasisPoint__SWIG_2((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_yieldValueBasisPoint__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, int jarg5) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions_yieldValueBasisPoint__SWIG_2((BondPtr const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_zSpread__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, unsigned long jarg9, double jarg10) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Size arg9 ;
  Rate arg10 ;
  Date *argp7 ;
  Spread result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = (Rate)jarg10; 
  {
    try {
      result = (Spread)BondFunctions_zSpread__SWIG_0((BondPtr const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_zSpread__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, unsigned long jarg9) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Size arg9 ;
  Date *argp7 ;
  Spread result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (Spread)BondFunctions_zSpread__SWIG_0((BondPtr const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_zSpread__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Date *argp7 ;
  Spread result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Spread)BondFunctions_zSpread__SWIG_0((BondPtr const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_zSpread__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Spread result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (Spread)BondFunctions_zSpread__SWIG_0((BondPtr const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_zSpread__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  BondPtr *arg1 = 0 ;
  Real arg2 ;
  boost::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Spread result;
  
  arg1 = (BondPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (boost::shared_ptr< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Spread)BondFunctions_zSpread__SWIG_0((BondPtr const &)*arg1,arg2,(boost::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondFunctions() {
  void * jresult ;
  BondFunctions *result = 0 ;
  
  {
    try {
      result = (BondFunctions *)new BondFunctions();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BondFunctions(void * jarg1) {
  BondFunctions *arg1 = (BondFunctions *) 0 ;
  
  arg1 = (BondFunctions *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloor_impliedVolatility__SWIG_0(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6, double jarg7, double jarg8, int jarg9, double jarg10) {
  double jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  Real arg10 ;
  Volatility result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  arg9 = (VolatilityType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (Volatility)CapFloorPtr_impliedVolatility__SWIG_0((CapFloorPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloor_impliedVolatility__SWIG_1(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6, double jarg7, double jarg8, int jarg9) {
  double jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  Volatility result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  arg9 = (VolatilityType)jarg9; 
  {
    try {
      result = (Volatility)CapFloorPtr_impliedVolatility__SWIG_0((CapFloorPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloor_impliedVolatility__SWIG_2(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6, double jarg7, double jarg8) {
  double jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  Volatility result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  {
    try {
      result = (Volatility)CapFloorPtr_impliedVolatility__SWIG_0((CapFloorPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloor_impliedVolatility__SWIG_3(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6, double jarg7) {
  double jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)CapFloorPtr_impliedVolatility__SWIG_0((CapFloorPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloor_impliedVolatility__SWIG_4(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6) {
  double jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  {
    try {
      result = (Volatility)CapFloorPtr_impliedVolatility__SWIG_0((CapFloorPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloor_impliedVolatility__SWIG_5(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5) {
  double jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Volatility result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Volatility)CapFloorPtr_impliedVolatility__SWIG_0((CapFloorPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloor_impliedVolatility__SWIG_6(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  double jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Volatility result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  {
    try {
      result = (Volatility)CapFloorPtr_impliedVolatility__SWIG_0((CapFloorPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_floatingLeg(void * jarg1) {
  void * jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Leg *result = 0 ;
  
  arg1 = (CapFloorPtr *)jarg1; 
  {
    try {
      result = (Leg *) &CapFloorPtr_floatingLeg((CapFloorPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_capRates(void * jarg1) {
  void * jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (CapFloorPtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &CapFloorPtr_capRates((CapFloorPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_floorRates(void * jarg1) {
  void * jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (CapFloorPtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &CapFloorPtr_floorRates((CapFloorPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_startDate(void * jarg1) {
  void * jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Date result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  {
    try {
      result = CapFloorPtr_startDate((CapFloorPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_maturityDate(void * jarg1) {
  void * jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  Date result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  {
    try {
      result = CapFloorPtr_maturityDate((CapFloorPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloor_atmRate(void * jarg1, void * jarg2) {
  double jresult ;
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  boost::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Rate result;
  
  arg1 = (CapFloorPtr *)jarg1; 
  arg2 = (boost::shared_ptr< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)CapFloorPtr_atmRate((CapFloorPtr const *)arg1,(boost::shared_ptr< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloor() {
  void * jresult ;
  CapFloorPtr *result = 0 ;
  
  {
    try {
      result = (CapFloorPtr *)new CapFloorPtr();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapFloor(void * jarg1) {
  CapFloorPtr *arg1 = (CapFloorPtr *) 0 ;
  
  arg1 = (CapFloorPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Cap(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  CapPtr *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapPtr *)new_CapPtr((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Cap(void * jarg1) {
  CapPtr *arg1 = (CapPtr *) 0 ;
  
  arg1 = (CapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Floor(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  FloorPtr *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloorPtr *)new_FloorPtr((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Floor(void * jarg1) {
  FloorPtr *arg1 = (FloorPtr *) 0 ;
  
  arg1 = (FloorPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Collar(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  CollarPtr *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CollarPtr *)new_CollarPtr((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Collar(void * jarg1) {
  CollarPtr *arg1 = (CollarPtr *) 0 ;
  
  arg1 = (CollarPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCapFloorEngine__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  BlackCapFloorEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackCapFloorEnginePtr *)new_BlackCapFloorEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCapFloorEngine__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  BlackCapFloorEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< OptionletVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackCapFloorEnginePtr *)new_BlackCapFloorEnginePtr__SWIG_1((Handle< YieldTermStructure > const &)*arg1,(Handle< OptionletVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackCapFloorEngine(void * jarg1) {
  BlackCapFloorEnginePtr *arg1 = (BlackCapFloorEnginePtr *) 0 ;
  
  arg1 = (BlackCapFloorEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BachelierCapFloorEngine__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  BachelierCapFloorEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierCapFloorEnginePtr *)new_BachelierCapFloorEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BachelierCapFloorEngine__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  BachelierCapFloorEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< OptionletVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierCapFloorEnginePtr *)new_BachelierCapFloorEnginePtr__SWIG_1((Handle< YieldTermStructure > const &)*arg1,(Handle< OptionletVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BachelierCapFloorEngine(void * jarg1) {
  BachelierCapFloorEnginePtr *arg1 = (BachelierCapFloorEnginePtr *) 0 ;
  
  arg1 = (BachelierCapFloorEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Dividend___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Dividend > *arg1 = (boost::shared_ptr< Dividend > *) 0 ;
  Dividend *result = 0 ;
  
  arg1 = (boost::shared_ptr< Dividend > *)jarg1; 
  {
    try {
      result = (Dividend *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Dividend_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Dividend > *arg1 = (boost::shared_ptr< Dividend > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Dividend > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Dividend_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Dividend() {
  void * jresult ;
  boost::shared_ptr< Dividend > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Dividend > *)new boost::shared_ptr< Dividend >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Dividend(void * jarg1) {
  boost::shared_ptr< Dividend > *arg1 = (boost::shared_ptr< Dividend > *) 0 ;
  
  arg1 = (boost::shared_ptr< Dividend > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Dividend_amount(void * jarg1) {
  double jresult ;
  boost::shared_ptr< Dividend > *arg1 = (boost::shared_ptr< Dividend > *) 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Dividend > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->amount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Dividend_date(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Dividend > *arg1 = (boost::shared_ptr< Dividend > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< Dividend > *)jarg1; 
  {
    try {
      result = (*arg1)->date();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedDividend(double jarg1, void * jarg2) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  FixedDividendPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedDividendPtr *)new_FixedDividendPtr(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedDividend(void * jarg1) {
  FixedDividendPtr *arg1 = (FixedDividendPtr *) 0 ;
  
  arg1 = (FixedDividendPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FractionalDividend(double jarg1, void * jarg2) {
  void * jresult ;
  Rate arg1 ;
  Date *arg2 = 0 ;
  FractionalDividendPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FractionalDividendPtr *)new_FractionalDividendPtr(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FractionalDividend(void * jarg1) {
  FractionalDividendPtr *arg1 = (FractionalDividendPtr *) 0 ;
  
  arg1 = (FractionalDividendPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  boost::shared_ptr< Dividend > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (boost::shared_ptr< Dividend > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Dividend > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< Dividend > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_DividendSchedule_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  std::vector< boost::shared_ptr< Dividend > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< Dividend > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_DividendSchedule_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  std::vector< boost::shared_ptr< Dividend > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< Dividend > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  std::vector< boost::shared_ptr< Dividend > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Dividend > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DividendSchedule__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< Dividend > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< Dividend > > *)new std::vector< boost::shared_ptr< Dividend > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DividendSchedule__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< Dividend > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< Dividend > > *)new std::vector< boost::shared_ptr< Dividend > >((std::vector< boost::shared_ptr< Dividend > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DividendSchedule__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< Dividend > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Dividend > > *)new_std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DividendSchedule_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Dividend > result;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Dividend >((const boost::shared_ptr< Dividend > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DividendSchedule_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Dividend > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< Dividend > *) &std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Dividend > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< Dividend > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Dividend > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< Dividend > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  std::vector< boost::shared_ptr< Dividend > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< Dividend > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< Dividend > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DividendSchedule_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< Dividend > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Dividend > > *)std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< Dividend > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< Dividend > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Dividend > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< Dividend > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< Dividend > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DividendSchedule_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< Dividend > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< Dividend > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Dividend > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< Dividend > > *)std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Repeat((boost::shared_ptr< Dividend > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< Dividend > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DividendSchedule_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  boost::shared_ptr< Dividend > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (boost::shared_ptr< Dividend > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Dividend > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Contains(arg1,(boost::shared_ptr< Dividend > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DividendSchedule_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  boost::shared_ptr< Dividend > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (boost::shared_ptr< Dividend > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Dividend > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< Dividend > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DividendSchedule_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  boost::shared_ptr< Dividend > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (boost::shared_ptr< Dividend > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Dividend > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< Dividend > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DividendSchedule_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  boost::shared_ptr< Dividend > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (boost::shared_ptr< Dividend > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Dividend > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_Dividend_Sg__Sg__Remove(arg1,(boost::shared_ptr< Dividend > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DividendSchedule(void * jarg1) {
  std::vector< boost::shared_ptr< Dividend > > *arg1 = (std::vector< boost::shared_ptr< Dividend > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< Dividend > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleZeroCouponBond__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, double jarg10) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *arg3 = 0 ;
  std::vector< boost::shared_ptr< Callability > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  DayCounter *arg8 = 0 ;
  Schedule *arg9 = 0 ;
  Real arg10 ;
  ConvertibleZeroCouponBondPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< boost::shared_ptr< Callability > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Schedule *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (ConvertibleZeroCouponBondPtr *)new_ConvertibleZeroCouponBondPtr__SWIG_0((boost::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< boost::shared_ptr< Dividend > > const &)*arg3,(std::vector< boost::shared_ptr< Callability > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(DayCounter const &)*arg8,(Schedule const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleZeroCouponBond__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *arg3 = 0 ;
  std::vector< boost::shared_ptr< Callability > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  DayCounter *arg8 = 0 ;
  Schedule *arg9 = 0 ;
  ConvertibleZeroCouponBondPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< boost::shared_ptr< Callability > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Schedule *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleZeroCouponBondPtr *)new_ConvertibleZeroCouponBondPtr__SWIG_0((boost::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< boost::shared_ptr< Dividend > > const &)*arg3,(std::vector< boost::shared_ptr< Callability > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(DayCounter const &)*arg8,(Schedule const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConvertibleZeroCouponBond(void * jarg1) {
  ConvertibleZeroCouponBondPtr *arg1 = (ConvertibleZeroCouponBondPtr *) 0 ;
  
  arg1 = (ConvertibleZeroCouponBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFixedCouponBond__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, double jarg11) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *arg3 = 0 ;
  std::vector< boost::shared_ptr< Callability > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Rate > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  ConvertibleFixedCouponBondPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< boost::shared_ptr< Callability > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Rate > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Schedule *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ConvertibleFixedCouponBondPtr *)new_ConvertibleFixedCouponBondPtr__SWIG_0((boost::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< boost::shared_ptr< Dividend > > const &)*arg3,(std::vector< boost::shared_ptr< Callability > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(std::vector< double > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFixedCouponBond__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *arg3 = 0 ;
  std::vector< boost::shared_ptr< Callability > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Rate > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  ConvertibleFixedCouponBondPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< boost::shared_ptr< Callability > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Rate > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Schedule *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleFixedCouponBondPtr *)new_ConvertibleFixedCouponBondPtr__SWIG_0((boost::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< boost::shared_ptr< Dividend > > const &)*arg3,(std::vector< boost::shared_ptr< Callability > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(std::vector< double > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConvertibleFixedCouponBond(void * jarg1) {
  ConvertibleFixedCouponBondPtr *arg1 = (ConvertibleFixedCouponBondPtr *) 0 ;
  
  arg1 = (ConvertibleFixedCouponBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFloatingRateBond__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, int jarg9, void * jarg10, void * jarg11, void * jarg12, double jarg13) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *arg3 = 0 ;
  std::vector< boost::shared_ptr< Callability > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  IborIndexPtr *arg8 = 0 ;
  Integer arg9 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  Schedule *arg12 = 0 ;
  Real arg13 ;
  ConvertibleFloatingRateBondPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< boost::shared_ptr< Callability > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (IborIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Integer)jarg9; 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg12 = (Schedule *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (ConvertibleFloatingRateBondPtr *)new_ConvertibleFloatingRateBondPtr__SWIG_0((boost::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< boost::shared_ptr< Dividend > > const &)*arg3,(std::vector< boost::shared_ptr< Callability > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(IborIndexPtr const &)*arg8,arg9,(std::vector< double > const &)*arg10,(DayCounter const &)*arg11,(Schedule const &)*arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFloatingRateBond__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, int jarg9, void * jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  boost::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< boost::shared_ptr< Dividend > > *arg3 = 0 ;
  std::vector< boost::shared_ptr< Callability > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  IborIndexPtr *arg8 = 0 ;
  Integer arg9 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  Schedule *arg12 = 0 ;
  ConvertibleFloatingRateBondPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Exercise > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Dividend > > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< boost::shared_ptr< Callability > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< Callability > > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (IborIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Integer)jarg9; 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg12 = (Schedule *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleFloatingRateBondPtr *)new_ConvertibleFloatingRateBondPtr__SWIG_0((boost::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< boost::shared_ptr< Dividend > > const &)*arg3,(std::vector< boost::shared_ptr< Callability > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(IborIndexPtr const &)*arg8,arg9,(std::vector< double > const &)*arg10,(DayCounter const &)*arg11,(Schedule const &)*arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConvertibleFloatingRateBond(void * jarg1) {
  ConvertibleFloatingRateBondPtr *arg1 = (ConvertibleFloatingRateBondPtr *) 0 ;
  
  arg1 = (ConvertibleFloatingRateBondPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialConvertibleEngine(void * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  GeneralizedBlackScholesProcessPtr *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Size arg3 ;
  BinomialConvertibleEnginePtr *result = 0 ;
  
  arg1 = (GeneralizedBlackScholesProcessPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GeneralizedBlackScholesProcessPtr const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialConvertibleEnginePtr *)new_BinomialConvertibleEnginePtr((GeneralizedBlackScholesProcessPtr const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialConvertibleEngine(void * jarg1) {
  BinomialConvertibleEnginePtr *arg1 = (BinomialConvertibleEnginePtr *) 0 ;
  
  arg1 = (BinomialConvertibleEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  DefaultProbabilityTermStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (DefaultProbabilityTermStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_DefaultProbabilityTermStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_DefaultProbabilityTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultProbabilityTermStructure() {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< DefaultProbabilityTermStructure > *)new boost::shared_ptr< DefaultProbabilityTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DefaultProbabilityTermStructure(void * jarg1) {
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_referenceDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_maxDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_maxTime(void * jarg1) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultProbability__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultProbability__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultProbability__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultProbability__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultProbability__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultProbability__SWIG_5(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultProbability__SWIG_6(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultProbability__SWIG_7(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_survivalProbability__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->survivalProbability((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_survivalProbability__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Probability)(*arg1)->survivalProbability((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_survivalProbability__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->survivalProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_survivalProbability__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Probability result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Probability)(*arg1)->survivalProbability(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultDensity__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->defaultDensity((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultDensity__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->defaultDensity((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultDensity__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->defaultDensity(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_defaultDensity__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(*arg1)->defaultDensity(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_hazardRate__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->hazardRate((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_hazardRate__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->hazardRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_hazardRate__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->hazardRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_hazardRate__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(*arg1)->hazardRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultProbabilityTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Handle< DefaultProbabilityTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< DefaultProbabilityTermStructure > *)new Handle< DefaultProbabilityTermStructure >((boost::shared_ptr< DefaultProbabilityTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultProbabilityTermStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< DefaultProbabilityTermStructure > *)new Handle< DefaultProbabilityTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  boost::shared_ptr< DefaultProbabilityTermStructure > result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< DefaultProbabilityTermStructure >((const boost::shared_ptr< DefaultProbabilityTermStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_DefaultProbabilityTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DefaultProbabilityTermStructureHandle(void * jarg1) {
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_5(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_6(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_7(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->survivalProbability((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Probability)(*arg1)->survivalProbability((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Probability)(*arg1)->survivalProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Probability result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Probability)(*arg1)->survivalProbability(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->defaultDensity((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->defaultDensity((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->defaultDensity(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(*arg1)->defaultDensity(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->hazardRate((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->hazardRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->hazardRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(*arg1)->hazardRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableDefaultProbabilityTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg1 = 0 ;
  RelinkableHandle< DefaultProbabilityTermStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< DefaultProbabilityTermStructure > *)new RelinkableHandle< DefaultProbabilityTermStructure >((boost::shared_ptr< DefaultProbabilityTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableDefaultProbabilityTermStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< DefaultProbabilityTermStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< DefaultProbabilityTermStructure > *)new RelinkableHandle< DefaultProbabilityTermStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableDefaultProbabilityTermStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< DefaultProbabilityTermStructure > *arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *) 0 ;
  boost::shared_ptr< DefaultProbabilityTermStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityTermStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< DefaultProbabilityTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableDefaultProbabilityTermStructureHandle(void * jarg1) {
  RelinkableHandle< DefaultProbabilityTermStructure > *arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatHazardRate__SWIG_0(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FlatHazardRatePtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatHazardRatePtr *)new_FlatHazardRatePtr__SWIG_0(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatHazardRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FlatHazardRatePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatHazardRatePtr *)new_FlatHazardRatePtr__SWIG_1((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FlatHazardRate(void * jarg1) {
  FlatHazardRatePtr *arg1 = (FlatHazardRatePtr *) 0 ;
  
  arg1 = (FlatHazardRatePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HazardRateCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Real > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  HazardRateCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (HazardRateCurvePtr *)new_HazardRateCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(BackwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HazardRateCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Real > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  HazardRateCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (HazardRateCurvePtr *)new_HazardRateCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HazardRateCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Real > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  HazardRateCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (HazardRateCurvePtr *)new_HazardRateCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HazardRateCurve_dates(void * jarg1) {
  void * jresult ;
  HazardRateCurvePtr *arg1 = (HazardRateCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (HazardRateCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &HazardRateCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HazardRateCurve_hazardRates(void * jarg1) {
  void * jresult ;
  HazardRateCurvePtr *arg1 = (HazardRateCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (HazardRateCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &HazardRateCurvePtr_hazardRates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HazardRateCurve_nodes(void * jarg1) {
  void * jresult ;
  HazardRateCurvePtr *arg1 = (HazardRateCurvePtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (HazardRateCurvePtr *)jarg1; 
  {
    try {
      result = HazardRateCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HazardRateCurve(void * jarg1) {
  HazardRateCurvePtr *arg1 = (HazardRateCurvePtr *) 0 ;
  
  arg1 = (HazardRateCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultDensityCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Real > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  DefaultDensityCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DefaultDensityCurvePtr *)new_DefaultDensityCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultDensityCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Real > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DefaultDensityCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DefaultDensityCurvePtr *)new_DefaultDensityCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultDensityCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Real > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  DefaultDensityCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DefaultDensityCurvePtr *)new_DefaultDensityCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultDensityCurve_dates(void * jarg1) {
  void * jresult ;
  DefaultDensityCurvePtr *arg1 = (DefaultDensityCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (DefaultDensityCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &DefaultDensityCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultDensityCurve_defaultDensities(void * jarg1) {
  void * jresult ;
  DefaultDensityCurvePtr *arg1 = (DefaultDensityCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (DefaultDensityCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &DefaultDensityCurvePtr_defaultDensities(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultDensityCurve_nodes(void * jarg1) {
  void * jresult ;
  DefaultDensityCurvePtr *arg1 = (DefaultDensityCurvePtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (DefaultDensityCurvePtr *)jarg1; 
  {
    try {
      result = DefaultDensityCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DefaultDensityCurve(void * jarg1) {
  DefaultDensityCurvePtr *arg1 = (DefaultDensityCurvePtr *) 0 ;
  
  arg1 = (DefaultDensityCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg1 = (boost::shared_ptr< DefaultProbabilityHelper > *) 0 ;
  DefaultProbabilityHelper *result = 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg1; 
  {
    try {
      result = (DefaultProbabilityHelper *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg1 = (boost::shared_ptr< DefaultProbabilityHelper > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultProbabilityHelper() {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityHelper > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< DefaultProbabilityHelper > *)new boost::shared_ptr< DefaultProbabilityHelper >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DefaultProbabilityHelper(void * jarg1) {
  boost::shared_ptr< DefaultProbabilityHelper > *arg1 = (boost::shared_ptr< DefaultProbabilityHelper > *) 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< DefaultProbabilityHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultProbabilityHelperVector__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)new std::vector< boost::shared_ptr< DefaultProbabilityHelper > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultProbabilityHelperVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)new std::vector< boost::shared_ptr< DefaultProbabilityHelper > >((std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultProbabilityHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)new_std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< DefaultProbabilityHelper > result;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< DefaultProbabilityHelper >((const boost::shared_ptr< DefaultProbabilityHelper > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< DefaultProbabilityHelper > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< DefaultProbabilityHelper > *) &std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< DefaultProbabilityHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< DefaultProbabilityHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityHelper > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Repeat((boost::shared_ptr< DefaultProbabilityHelper > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Contains(arg1,(boost::shared_ptr< DefaultProbabilityHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< DefaultProbabilityHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< DefaultProbabilityHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  boost::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< DefaultProbabilityHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< DefaultProbabilityHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Remove(arg1,(boost::shared_ptr< DefaultProbabilityHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DefaultProbabilityHelperVector(void * jarg1) {
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_0(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, void * jarg8, double jarg9, void * jarg10, unsigned int jarg11, unsigned int jarg12) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  SpreadCdsHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (SpreadCdsHelperPtr *)new_SpreadCdsHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_1(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, void * jarg8, double jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  SpreadCdsHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (SpreadCdsHelperPtr *)new_SpreadCdsHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_2(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, void * jarg8, double jarg9, void * jarg10) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  SpreadCdsHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadCdsHelperPtr *)new_SpreadCdsHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_3(double jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, void * jarg8, double jarg9, void * jarg10, unsigned int jarg11, unsigned int jarg12) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  SpreadCdsHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (SpreadCdsHelperPtr *)new_SpreadCdsHelperPtr__SWIG_3(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_4(double jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, void * jarg8, double jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  SpreadCdsHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (SpreadCdsHelperPtr *)new_SpreadCdsHelperPtr__SWIG_3(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_5(double jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, void * jarg8, double jarg9, void * jarg10) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  SpreadCdsHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DateGeneration::Rule)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadCdsHelperPtr *)new_SpreadCdsHelperPtr__SWIG_3(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SpreadCdsHelper(void * jarg1) {
  SpreadCdsHelperPtr *arg1 = (SpreadCdsHelperPtr *) 0 ;
  
  arg1 = (SpreadCdsHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_0(void * jarg1, double jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6, int jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  UpfrontCdsHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DateGeneration::Rule)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelperPtr *)new_UpfrontCdsHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_1(void * jarg1, double jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6, int jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  UpfrontCdsHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DateGeneration::Rule)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelperPtr *)new_UpfrontCdsHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_2(void * jarg1, double jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6, int jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, unsigned int jarg12) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  UpfrontCdsHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DateGeneration::Rule)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  {
    try {
      result = (UpfrontCdsHelperPtr *)new_UpfrontCdsHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_3(void * jarg1, double jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6, int jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  UpfrontCdsHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DateGeneration::Rule)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (UpfrontCdsHelperPtr *)new_UpfrontCdsHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_4(double jarg1, double jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6, int jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  UpfrontCdsHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DateGeneration::Rule)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelperPtr *)new_UpfrontCdsHelperPtr__SWIG_4(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_5(double jarg1, double jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6, int jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  UpfrontCdsHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DateGeneration::Rule)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelperPtr *)new_UpfrontCdsHelperPtr__SWIG_4(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_6(double jarg1, double jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6, int jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, unsigned int jarg12) {
  void * jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  UpfrontCdsHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DateGeneration::Rule)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  {
    try {
      result = (UpfrontCdsHelperPtr *)new_UpfrontCdsHelperPtr__SWIG_4(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_7(double jarg1, double jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6, int jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11) {
  void * jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  UpfrontCdsHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DateGeneration::Rule)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (UpfrontCdsHelperPtr *)new_UpfrontCdsHelperPtr__SWIG_4(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UpfrontCdsHelper(void * jarg1) {
  UpfrontCdsHelperPtr *arg1 = (UpfrontCdsHelperPtr *) 0 ;
  
  arg1 = (UpfrontCdsHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HazardRate() {
  void * jresult ;
  HazardRate *result = 0 ;
  
  {
    try {
      result = (HazardRate *)new HazardRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HazardRate(void * jarg1) {
  HazardRate *arg1 = (HazardRate *) 0 ;
  
  arg1 = (HazardRate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultDensity() {
  void * jresult ;
  DefaultDensity *result = 0 ;
  
  {
    try {
      result = (DefaultDensity *)new DefaultDensity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DefaultDensity(void * jarg1) {
  DefaultDensity *arg1 = (DefaultDensity *) 0 ;
  
  arg1 = (DefaultDensity *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  BackwardFlat *arg5 = 0 ;
  PiecewiseFlatHazardRatePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRatePtr *)new_PiecewiseFlatHazardRatePtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg2,(DayCounter const &)*arg3,arg4,(BackwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  PiecewiseFlatHazardRatePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (PiecewiseFlatHazardRatePtr *)new_PiecewiseFlatHazardRatePtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseFlatHazardRatePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRatePtr *)new_PiecewiseFlatHazardRatePtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_3(int jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  BackwardFlat *arg6 = 0 ;
  PiecewiseFlatHazardRatePtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (BackwardFlat *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRatePtr *)new_PiecewiseFlatHazardRatePtr__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg3,(DayCounter const &)*arg4,arg5,(BackwardFlat const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_4(int jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  PiecewiseFlatHazardRatePtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (PiecewiseFlatHazardRatePtr *)new_PiecewiseFlatHazardRatePtr__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseFlatHazardRatePtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRatePtr *)new_PiecewiseFlatHazardRatePtr__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< DefaultProbabilityHelper > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatHazardRate_dates(void * jarg1) {
  void * jresult ;
  PiecewiseFlatHazardRatePtr *arg1 = (PiecewiseFlatHazardRatePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (PiecewiseFlatHazardRatePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &PiecewiseFlatHazardRatePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatHazardRate_times(void * jarg1) {
  void * jresult ;
  PiecewiseFlatHazardRatePtr *arg1 = (PiecewiseFlatHazardRatePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (PiecewiseFlatHazardRatePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &PiecewiseFlatHazardRatePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatHazardRate_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseFlatHazardRatePtr *arg1 = (PiecewiseFlatHazardRatePtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (PiecewiseFlatHazardRatePtr *)jarg1; 
  {
    try {
      result = PiecewiseFlatHazardRatePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseFlatHazardRate(void * jarg1) {
  PiecewiseFlatHazardRatePtr *arg1 = (PiecewiseFlatHazardRatePtr *) 0 ;
  
  arg1 = (PiecewiseFlatHazardRatePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Protection() {
  void * jresult ;
  Protection *result = 0 ;
  
  {
    try {
      result = (Protection *)new Protection();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Protection(void * jarg1) {
  Protection *arg1 = (Protection *) 0 ;
  
  arg1 = (Protection *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_0(int jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, void * jarg6, unsigned int jarg7, unsigned int jarg8) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  CreditDefaultSwapPtr *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (CreditDefaultSwapPtr *)new_CreditDefaultSwapPtr__SWIG_0(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_1(int jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  CreditDefaultSwapPtr *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (CreditDefaultSwapPtr *)new_CreditDefaultSwapPtr__SWIG_0(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_2(int jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  CreditDefaultSwapPtr *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwapPtr *)new_CreditDefaultSwapPtr__SWIG_0(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_3(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, unsigned int jarg9) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  CreditDefaultSwapPtr *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Schedule *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (CreditDefaultSwapPtr *)new_CreditDefaultSwapPtr__SWIG_3(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_4(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  CreditDefaultSwapPtr *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Schedule *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (CreditDefaultSwapPtr *)new_CreditDefaultSwapPtr__SWIG_3(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_5(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  CreditDefaultSwapPtr *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Schedule *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwapPtr *)new_CreditDefaultSwapPtr__SWIG_3(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_side(void * jarg1) {
  int jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Protection::Side result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Protection::Side)CreditDefaultSwapPtr_side((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_notional(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Real)CreditDefaultSwapPtr_notional((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_runningSpread(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Rate result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Rate)CreditDefaultSwapPtr_runningSpread((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_upfront(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  doubleOrNull result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (doubleOrNull)CreditDefaultSwapPtr_upfront((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_settlesAccrual(void * jarg1) {
  unsigned int jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  bool result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (bool)CreditDefaultSwapPtr_settlesAccrual((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_paysAtDefaultTime(void * jarg1) {
  unsigned int jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  bool result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (bool)CreditDefaultSwapPtr_paysAtDefaultTime((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_fairSpread(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Rate result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Rate)CreditDefaultSwapPtr_fairSpread((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_fairUpfront(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Rate result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Rate)CreditDefaultSwapPtr_fairUpfront((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_couponLegBPS(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Real)CreditDefaultSwapPtr_couponLegBPS((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_couponLegNPV(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Real)CreditDefaultSwapPtr_couponLegNPV((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_defaultLegNPV(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Real)CreditDefaultSwapPtr_defaultLegNPV((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_upfrontBPS(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Real)CreditDefaultSwapPtr_upfrontBPS((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_upfrontNPV(void * jarg1) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = (Real)CreditDefaultSwapPtr_upfrontNPV((CreditDefaultSwapPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_impliedHazardRate__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Rate result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Rate)CreditDefaultSwapPtr_impliedHazardRate__SWIG_0((CreditDefaultSwapPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_impliedHazardRate__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  Rate result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Rate)CreditDefaultSwapPtr_impliedHazardRate__SWIG_0((CreditDefaultSwapPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_impliedHazardRate__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Rate result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)CreditDefaultSwapPtr_impliedHazardRate__SWIG_0((CreditDefaultSwapPtr const *)arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_coupons(void * jarg1) {
  void * jresult ;
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  std::vector< boost::shared_ptr< CashFlow > > result;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      result = CreditDefaultSwapPtr_coupons(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< boost::shared_ptr< CashFlow > >((const std::vector< boost::shared_ptr< CashFlow > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CreditDefaultSwap(void * jarg1) {
  CreditDefaultSwapPtr *arg1 = (CreditDefaultSwapPtr *) 0 ;
  
  arg1 = (CreditDefaultSwapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MidPointCdsEngine(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  MidPointCdsEnginePtr *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MidPointCdsEnginePtr *)new_MidPointCdsEnginePtr((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MidPointCdsEngine(void * jarg1) {
  MidPointCdsEnginePtr *arg1 = (MidPointCdsEnginePtr *) 0 ;
  
  arg1 = (MidPointCdsEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntegralCdsEngine__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg2 = 0 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  bool arg5 ;
  IntegralCdsEnginePtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< DefaultProbabilityTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (IntegralCdsEnginePtr *)new_IntegralCdsEnginePtr__SWIG_0((Period const &)*arg1,(Handle< DefaultProbabilityTermStructure > const &)*arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IntegralCdsEngine__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg2 = 0 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  IntegralCdsEnginePtr *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< DefaultProbabilityTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (IntegralCdsEnginePtr *)new_IntegralCdsEnginePtr__SWIG_0((Period const &)*arg1,(Handle< DefaultProbabilityTermStructure > const &)*arg2,arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IntegralCdsEngine(void * jarg1) {
  IntegralCdsEnginePtr *arg1 = (IntegralCdsEnginePtr *) 0 ;
  
  arg1 = (IntegralCdsEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  DiscountCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountCurvePtr *)new_DiscountCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogLinear const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DiscountCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountCurvePtr *)new_DiscountCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  DiscountCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountCurvePtr *)new_DiscountCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_times(void * jarg1) {
  void * jresult ;
  DiscountCurvePtr *arg1 = (DiscountCurvePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (DiscountCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &DiscountCurvePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_data(void * jarg1) {
  void * jresult ;
  DiscountCurvePtr *arg1 = (DiscountCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (DiscountCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &DiscountCurvePtr_data(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_dates(void * jarg1) {
  void * jresult ;
  DiscountCurvePtr *arg1 = (DiscountCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (DiscountCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &DiscountCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_discounts(void * jarg1) {
  void * jresult ;
  DiscountCurvePtr *arg1 = (DiscountCurvePtr *) 0 ;
  std::vector< DiscountFactor > *result = 0 ;
  
  arg1 = (DiscountCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< DiscountFactor > *) &DiscountCurvePtr_discounts(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_nodes(void * jarg1) {
  void * jresult ;
  DiscountCurvePtr *arg1 = (DiscountCurvePtr *) 0 ;
  std::vector< std::pair< Date,DiscountFactor > > result;
  
  arg1 = (DiscountCurvePtr *)jarg1; 
  {
    try {
      result = DiscountCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,DiscountFactor > >((const std::vector< std::pair< Date,DiscountFactor > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DiscountCurve(void * jarg1) {
  DiscountCurvePtr *arg1 = (DiscountCurvePtr *) 0 ;
  
  arg1 = (DiscountCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NormalDistribution__SWIG_0(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  NormalDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (NormalDistribution *)new NormalDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NormalDistribution__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  NormalDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (NormalDistribution *)new NormalDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NormalDistribution__SWIG_2() {
  void * jresult ;
  NormalDistribution *result = 0 ;
  
  {
    try {
      result = (NormalDistribution *)new NormalDistribution();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NormalDistribution_call(void * jarg1, double jarg2) {
  double jresult ;
  NormalDistribution *arg1 = (NormalDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (NormalDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NormalDistribution_derivative(void * jarg1, double jarg2) {
  double jresult ;
  NormalDistribution *arg1 = (NormalDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (NormalDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->derivative(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NormalDistribution(void * jarg1) {
  NormalDistribution *arg1 = (NormalDistribution *) 0 ;
  
  arg1 = (NormalDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CumulativeNormalDistribution__SWIG_0(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  CumulativeNormalDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (CumulativeNormalDistribution *)new CumulativeNormalDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CumulativeNormalDistribution__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  CumulativeNormalDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (CumulativeNormalDistribution *)new CumulativeNormalDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CumulativeNormalDistribution__SWIG_2() {
  void * jresult ;
  CumulativeNormalDistribution *result = 0 ;
  
  {
    try {
      result = (CumulativeNormalDistribution *)new CumulativeNormalDistribution();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CumulativeNormalDistribution_call(void * jarg1, double jarg2) {
  double jresult ;
  CumulativeNormalDistribution *arg1 = (CumulativeNormalDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (CumulativeNormalDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CumulativeNormalDistribution_derivative(void * jarg1, double jarg2) {
  double jresult ;
  CumulativeNormalDistribution *arg1 = (CumulativeNormalDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (CumulativeNormalDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->derivative(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CumulativeNormalDistribution(void * jarg1) {
  CumulativeNormalDistribution *arg1 = (CumulativeNormalDistribution *) 0 ;
  
  arg1 = (CumulativeNormalDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseCumulativeNormal__SWIG_0(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  InverseCumulativeNormal *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (InverseCumulativeNormal *)new InverseCumulativeNormal(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseCumulativeNormal__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  InverseCumulativeNormal *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (InverseCumulativeNormal *)new InverseCumulativeNormal(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseCumulativeNormal__SWIG_2() {
  void * jresult ;
  InverseCumulativeNormal *result = 0 ;
  
  {
    try {
      result = (InverseCumulativeNormal *)new InverseCumulativeNormal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InverseCumulativeNormal_call(void * jarg1, double jarg2) {
  double jresult ;
  InverseCumulativeNormal *arg1 = (InverseCumulativeNormal *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (InverseCumulativeNormal *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InverseCumulativeNormal(void * jarg1) {
  InverseCumulativeNormal *arg1 = (InverseCumulativeNormal *) 0 ;
  
  arg1 = (InverseCumulativeNormal *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInverseCumulativeNormal__SWIG_0(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  MoroInverseCumulativeNormal *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (MoroInverseCumulativeNormal *)new MoroInverseCumulativeNormal(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInverseCumulativeNormal__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  MoroInverseCumulativeNormal *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (MoroInverseCumulativeNormal *)new MoroInverseCumulativeNormal(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInverseCumulativeNormal__SWIG_2() {
  void * jresult ;
  MoroInverseCumulativeNormal *result = 0 ;
  
  {
    try {
      result = (MoroInverseCumulativeNormal *)new MoroInverseCumulativeNormal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MoroInverseCumulativeNormal_call(void * jarg1, double jarg2) {
  double jresult ;
  MoroInverseCumulativeNormal *arg1 = (MoroInverseCumulativeNormal *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (MoroInverseCumulativeNormal *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInverseCumulativeNormal(void * jarg1) {
  MoroInverseCumulativeNormal *arg1 = (MoroInverseCumulativeNormal *) 0 ;
  
  arg1 = (MoroInverseCumulativeNormal *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BivariateCumulativeNormalDistribution(double jarg1) {
  void * jresult ;
  Real arg1 ;
  BivariateCumulativeNormalDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (BivariateCumulativeNormalDistribution *)new BivariateCumulativeNormalDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BivariateCumulativeNormalDistribution_call(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  BivariateCumulativeNormalDistribution *arg1 = (BivariateCumulativeNormalDistribution *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (BivariateCumulativeNormalDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BivariateCumulativeNormalDistribution(void * jarg1) {
  BivariateCumulativeNormalDistribution *arg1 = (BivariateCumulativeNormalDistribution *) 0 ;
  
  arg1 = (BivariateCumulativeNormalDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialDistribution(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  BigNatural arg2 ;
  BinomialDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (BinomialDistribution *)new BinomialDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BinomialDistribution_call(void * jarg1, unsigned long jarg2) {
  double jresult ;
  BinomialDistribution *arg1 = (BinomialDistribution *) 0 ;
  BigNatural arg2 ;
  Real result;
  
  arg1 = (BinomialDistribution *)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialDistribution(void * jarg1) {
  BinomialDistribution *arg1 = (BinomialDistribution *) 0 ;
  
  arg1 = (BinomialDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CumulativeBinomialDistribution(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  BigNatural arg2 ;
  CumulativeBinomialDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (CumulativeBinomialDistribution *)new CumulativeBinomialDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CumulativeBinomialDistribution_call(void * jarg1, unsigned long jarg2) {
  double jresult ;
  CumulativeBinomialDistribution *arg1 = (CumulativeBinomialDistribution *) 0 ;
  BigNatural arg2 ;
  Real result;
  
  arg1 = (CumulativeBinomialDistribution *)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CumulativeBinomialDistribution(void * jarg1) {
  CumulativeBinomialDistribution *arg1 = (CumulativeBinomialDistribution *) 0 ;
  
  arg1 = (CumulativeBinomialDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BivariateCumulativeNormalDistributionDr78(double jarg1) {
  void * jresult ;
  Real arg1 ;
  BivariateCumulativeNormalDistributionDr78 *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (BivariateCumulativeNormalDistributionDr78 *)new BivariateCumulativeNormalDistributionDr78(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BivariateCumulativeNormalDistributionDr78_call(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  BivariateCumulativeNormalDistributionDr78 *arg1 = (BivariateCumulativeNormalDistributionDr78 *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (BivariateCumulativeNormalDistributionDr78 *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BivariateCumulativeNormalDistributionDr78(void * jarg1) {
  BivariateCumulativeNormalDistributionDr78 *arg1 = (BivariateCumulativeNormalDistributionDr78 *) 0 ;
  
  arg1 = (BivariateCumulativeNormalDistributionDr78 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BivariateCumulativeNormalDistributionWe04DP(double jarg1) {
  void * jresult ;
  Real arg1 ;
  BivariateCumulativeNormalDistributionWe04DP *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (BivariateCumulativeNormalDistributionWe04DP *)new BivariateCumulativeNormalDistributionWe04DP(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BivariateCumulativeNormalDistributionWe04DP_call(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  BivariateCumulativeNormalDistributionWe04DP *arg1 = (BivariateCumulativeNormalDistributionWe04DP *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (BivariateCumulativeNormalDistributionWe04DP *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BivariateCumulativeNormalDistributionWe04DP(void * jarg1) {
  BivariateCumulativeNormalDistributionWe04DP *arg1 = (BivariateCumulativeNormalDistributionWe04DP *) 0 ;
  
  arg1 = (BivariateCumulativeNormalDistributionWe04DP *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CumulativeChiSquareDistribution(double jarg1) {
  void * jresult ;
  Real arg1 ;
  CumulativeChiSquareDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (CumulativeChiSquareDistribution *)new CumulativeChiSquareDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CumulativeChiSquareDistribution_call(void * jarg1, double jarg2) {
  double jresult ;
  CumulativeChiSquareDistribution *arg1 = (CumulativeChiSquareDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (CumulativeChiSquareDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CumulativeChiSquareDistribution(void * jarg1) {
  CumulativeChiSquareDistribution *arg1 = (CumulativeChiSquareDistribution *) 0 ;
  
  arg1 = (CumulativeChiSquareDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonCentralCumulativeChiSquareDistribution(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  NonCentralCumulativeChiSquareDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (NonCentralCumulativeChiSquareDistribution *)new NonCentralCumulativeChiSquareDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NonCentralCumulativeChiSquareDistribution_call(void * jarg1, double jarg2) {
  double jresult ;
  NonCentralCumulativeChiSquareDistribution *arg1 = (NonCentralCumulativeChiSquareDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (NonCentralCumulativeChiSquareDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NonCentralCumulativeChiSquareDistribution(void * jarg1) {
  NonCentralCumulativeChiSquareDistribution *arg1 = (NonCentralCumulativeChiSquareDistribution *) 0 ;
  
  arg1 = (NonCentralCumulativeChiSquareDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_0(double jarg1, double jarg2, unsigned long jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  Real arg4 ;
  InverseNonCentralCumulativeChiSquareDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InverseNonCentralCumulativeChiSquareDistribution *)new InverseNonCentralCumulativeChiSquareDistribution(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_1(double jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  InverseNonCentralCumulativeChiSquareDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (InverseNonCentralCumulativeChiSquareDistribution *)new InverseNonCentralCumulativeChiSquareDistribution(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_2(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  InverseNonCentralCumulativeChiSquareDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (InverseNonCentralCumulativeChiSquareDistribution *)new InverseNonCentralCumulativeChiSquareDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InverseNonCentralCumulativeChiSquareDistribution_call(void * jarg1, double jarg2) {
  double jresult ;
  InverseNonCentralCumulativeChiSquareDistribution *arg1 = (InverseNonCentralCumulativeChiSquareDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (InverseNonCentralCumulativeChiSquareDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InverseNonCentralCumulativeChiSquareDistribution(void * jarg1) {
  InverseNonCentralCumulativeChiSquareDistribution *arg1 = (InverseNonCentralCumulativeChiSquareDistribution *) 0 ;
  
  arg1 = (InverseNonCentralCumulativeChiSquareDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CumulativeGammaDistribution(double jarg1) {
  void * jresult ;
  Real arg1 ;
  CumulativeGammaDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (CumulativeGammaDistribution *)new CumulativeGammaDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CumulativeGammaDistribution_call(void * jarg1, double jarg2) {
  double jresult ;
  CumulativeGammaDistribution *arg1 = (CumulativeGammaDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (CumulativeGammaDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CumulativeGammaDistribution(void * jarg1) {
  CumulativeGammaDistribution *arg1 = (CumulativeGammaDistribution *) 0 ;
  
  arg1 = (CumulativeGammaDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GammaFunction_logValue(void * jarg1, double jarg2) {
  double jresult ;
  GammaFunction *arg1 = (GammaFunction *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (GammaFunction *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->logValue(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GammaFunction() {
  void * jresult ;
  GammaFunction *result = 0 ;
  
  {
    try {
      result = (GammaFunction *)new GammaFunction();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GammaFunction(void * jarg1) {
  GammaFunction *arg1 = (GammaFunction *) 0 ;
  
  arg1 = (GammaFunction *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PoissonDistribution(double jarg1) {
  void * jresult ;
  Real arg1 ;
  PoissonDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (PoissonDistribution *)new PoissonDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PoissonDistribution_call(void * jarg1, unsigned long jarg2) {
  double jresult ;
  PoissonDistribution *arg1 = (PoissonDistribution *) 0 ;
  BigNatural arg2 ;
  Real result;
  
  arg1 = (PoissonDistribution *)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PoissonDistribution(void * jarg1) {
  PoissonDistribution *arg1 = (PoissonDistribution *) 0 ;
  
  arg1 = (PoissonDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CumulativePoissonDistribution(double jarg1) {
  void * jresult ;
  Real arg1 ;
  CumulativePoissonDistribution *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (CumulativePoissonDistribution *)new CumulativePoissonDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CumulativePoissonDistribution_call(void * jarg1, unsigned long jarg2) {
  double jresult ;
  CumulativePoissonDistribution *arg1 = (CumulativePoissonDistribution *) 0 ;
  BigNatural arg2 ;
  Real result;
  
  arg1 = (CumulativePoissonDistribution *)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CumulativePoissonDistribution(void * jarg1) {
  CumulativePoissonDistribution *arg1 = (CumulativePoissonDistribution *) 0 ;
  
  arg1 = (CumulativePoissonDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseCumulativePoisson(double jarg1) {
  void * jresult ;
  Real arg1 ;
  InverseCumulativePoisson *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (InverseCumulativePoisson *)new InverseCumulativePoisson(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InverseCumulativePoisson_call(void * jarg1, double jarg2) {
  double jresult ;
  InverseCumulativePoisson *arg1 = (InverseCumulativePoisson *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (InverseCumulativePoisson *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InverseCumulativePoisson(void * jarg1) {
  InverseCumulativePoisson *arg1 = (InverseCumulativePoisson *) 0 ;
  
  arg1 = (InverseCumulativePoisson *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StudentDistribution(int jarg1) {
  void * jresult ;
  Integer arg1 ;
  StudentDistribution *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  {
    try {
      result = (StudentDistribution *)new StudentDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_StudentDistribution_call(void * jarg1, double jarg2) {
  double jresult ;
  StudentDistribution *arg1 = (StudentDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (StudentDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StudentDistribution(void * jarg1) {
  StudentDistribution *arg1 = (StudentDistribution *) 0 ;
  
  arg1 = (StudentDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CumulativeStudentDistribution(int jarg1) {
  void * jresult ;
  Integer arg1 ;
  CumulativeStudentDistribution *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  {
    try {
      result = (CumulativeStudentDistribution *)new CumulativeStudentDistribution(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CumulativeStudentDistribution_call(void * jarg1, double jarg2) {
  double jresult ;
  CumulativeStudentDistribution *arg1 = (CumulativeStudentDistribution *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (CumulativeStudentDistribution *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CumulativeStudentDistribution(void * jarg1) {
  CumulativeStudentDistribution *arg1 = (CumulativeStudentDistribution *) 0 ;
  
  arg1 = (CumulativeStudentDistribution *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseCumulativeStudent__SWIG_0(int jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Size arg3 ;
  InverseCumulativeStudent *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (InverseCumulativeStudent *)new InverseCumulativeStudent(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseCumulativeStudent__SWIG_1(int jarg1, double jarg2) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  InverseCumulativeStudent *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (InverseCumulativeStudent *)new InverseCumulativeStudent(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InverseCumulativeStudent__SWIG_2(int jarg1) {
  void * jresult ;
  Integer arg1 ;
  InverseCumulativeStudent *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  {
    try {
      result = (InverseCumulativeStudent *)new InverseCumulativeStudent(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InverseCumulativeStudent_call(void * jarg1, double jarg2) {
  double jresult ;
  InverseCumulativeStudent *arg1 = (InverseCumulativeStudent *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (InverseCumulativeStudent *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InverseCumulativeStudent(void * jarg1) {
  InverseCumulativeStudent *arg1 = (InverseCumulativeStudent *) 0 ;
  
  arg1 = (InverseCumulativeStudent *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Money__SWIG_0(void * jarg1, double jarg2) {
  void * jresult ;
  Currency *arg1 = 0 ;
  Decimal arg2 ;
  Money *result = 0 ;
  
  arg1 = (Currency *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg2 = (Decimal)jarg2; 
  {
    try {
      result = (Money *)new Money((Currency const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Money__SWIG_1(double jarg1, void * jarg2) {
  void * jresult ;
  Decimal arg1 ;
  Currency *arg2 = 0 ;
  Money *result = 0 ;
  
  arg1 = (Decimal)jarg1; 
  arg2 = (Currency *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Money *)new Money(arg1,(Currency const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Money_currency(void * jarg1) {
  void * jresult ;
  Money *arg1 = (Money *) 0 ;
  Currency *result = 0 ;
  
  arg1 = (Money *)jarg1; 
  {
    try {
      result = (Currency *) &((Money const *)arg1)->currency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Money_value(void * jarg1) {
  double jresult ;
  Money *arg1 = (Money *) 0 ;
  Decimal result;
  
  arg1 = (Money *)jarg1; 
  {
    try {
      result = (Decimal)((Money const *)arg1)->value();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Money_rounded(void * jarg1) {
  void * jresult ;
  Money *arg1 = (Money *) 0 ;
  SwigValueWrapper< Money > result;
  
  arg1 = (Money *)jarg1; 
  {
    try {
      result = ((Money const *)arg1)->rounded();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Money((const Money &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Money_setConversionType(int jarg1) {
  Money::ConversionType arg1 ;
  
  arg1 = (Money::ConversionType)jarg1; 
  {
    try {
      Money_setConversionType(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Money_setBaseCurrency(void * jarg1) {
  Currency *arg1 = 0 ;
  
  arg1 = (Currency *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return ;
  } 
  {
    try {
      Money_setBaseCurrency((Currency const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Money(void * jarg1) {
  Money *arg1 = (Money *) 0 ;
  
  arg1 = (Money *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExchangeRate(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  Currency *arg1 = 0 ;
  Currency *arg2 = 0 ;
  Decimal arg3 ;
  ExchangeRate *result = 0 ;
  
  arg1 = (Currency *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg2 = (Currency *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg3 = (Decimal)jarg3; 
  {
    try {
      result = (ExchangeRate *)new ExchangeRate((Currency const &)*arg1,(Currency const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ExchangeRate_source(void * jarg1) {
  void * jresult ;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  Currency *result = 0 ;
  
  arg1 = (ExchangeRate *)jarg1; 
  {
    try {
      result = (Currency *) &((ExchangeRate const *)arg1)->source();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ExchangeRate_target(void * jarg1) {
  void * jresult ;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  Currency *result = 0 ;
  
  arg1 = (ExchangeRate *)jarg1; 
  {
    try {
      result = (Currency *) &((ExchangeRate const *)arg1)->target();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ExchangeRate_type(void * jarg1) {
  int jresult ;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  ExchangeRate::Type result;
  
  arg1 = (ExchangeRate *)jarg1; 
  {
    try {
      result = (ExchangeRate::Type)((ExchangeRate const *)arg1)->type();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ExchangeRate_rate(void * jarg1) {
  double jresult ;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  Decimal result;
  
  arg1 = (ExchangeRate *)jarg1; 
  {
    try {
      result = (Decimal)((ExchangeRate const *)arg1)->rate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ExchangeRate_exchange(void * jarg1, void * jarg2) {
  void * jresult ;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  Money *arg2 = 0 ;
  SwigValueWrapper< Money > result;
  
  arg1 = (ExchangeRate *)jarg1; 
  arg2 = (Money *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Money const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((ExchangeRate const *)arg1)->exchange((Money const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Money((const Money &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ExchangeRate_chain(void * jarg1, void * jarg2) {
  void * jresult ;
  ExchangeRate *arg1 = 0 ;
  ExchangeRate *arg2 = 0 ;
  SwigValueWrapper< ExchangeRate > result;
  
  arg1 = (ExchangeRate *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ExchangeRate const & type is null", 0);
    return 0;
  } 
  arg2 = (ExchangeRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ExchangeRate const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ExchangeRate::chain((ExchangeRate const &)*arg1,(ExchangeRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new ExchangeRate((const ExchangeRate &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExchangeRate(void * jarg1) {
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  
  arg1 = (ExchangeRate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ExchangeRateManager_instance() {
  void * jresult ;
  ExchangeRateManager *result = 0 ;
  
  {
    try {
      result = (ExchangeRateManager *) &ExchangeRateManager::instance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ExchangeRateManager_add__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  ExchangeRate *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  
  arg1 = (ExchangeRateManager *)jarg1; 
  arg2 = (ExchangeRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ExchangeRate const & type is null", 0);
    return ;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((ExchangeRate const &)*arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ExchangeRateManager_add__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  ExchangeRate *arg2 = 0 ;
  Date *arg3 = 0 ;
  
  arg1 = (ExchangeRateManager *)jarg1; 
  arg2 = (ExchangeRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ExchangeRate const & type is null", 0);
    return ;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((ExchangeRate const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ExchangeRateManager_add__SWIG_2(void * jarg1, void * jarg2) {
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  ExchangeRate *arg2 = 0 ;
  
  arg1 = (ExchangeRateManager *)jarg1; 
  arg2 = (ExchangeRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ExchangeRate const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((ExchangeRate const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ExchangeRateManager_lookup__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  Currency *arg2 = 0 ;
  Currency *arg3 = 0 ;
  Date *arg4 = 0 ;
  ExchangeRate::Type arg5 ;
  SwigValueWrapper< ExchangeRate > result;
  
  arg1 = (ExchangeRateManager *)jarg1; 
  arg2 = (Currency *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg3 = (Currency *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (ExchangeRate::Type)jarg5; 
  {
    try {
      result = ((ExchangeRateManager const *)arg1)->lookup((Currency const &)*arg2,(Currency const &)*arg3,(Date const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new ExchangeRate((const ExchangeRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ExchangeRateManager_lookup__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  Currency *arg2 = 0 ;
  Currency *arg3 = 0 ;
  Date *arg4 = 0 ;
  SwigValueWrapper< ExchangeRate > result;
  
  arg1 = (ExchangeRateManager *)jarg1; 
  arg2 = (Currency *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg3 = (Currency *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((ExchangeRateManager const *)arg1)->lookup((Currency const &)*arg2,(Currency const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new ExchangeRate((const ExchangeRate &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ExchangeRateManager_clear(void * jarg1) {
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  
  arg1 = (ExchangeRateManager *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExchangeRateManager(void * jarg1) {
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  
  arg1 = (ExchangeRateManager *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Futures() {
  void * jresult ;
  Futures *result = 0 ;
  
  {
    try {
      result = (Futures *)new Futures();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Futures(void * jarg1) {
  Futures *arg1 = (Futures *) 0 ;
  
  arg1 = (Futures *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TimeBasket__SWIG_0() {
  void * jresult ;
  TimeBasket *result = 0 ;
  
  {
    try {
      result = (TimeBasket *)new TimeBasket();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TimeBasket__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Real > *arg2 = 0 ;
  TimeBasket *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TimeBasket *)new TimeBasket((std::vector< Date > const &)*arg1,(std::vector< Real > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_TimeBasket_size(void * jarg1) {
  unsigned long jresult ;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  Size result;
  
  arg1 = (TimeBasket *)jarg1; 
  {
    try {
      result = (arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TimeBasket_rebin(void * jarg1, void * jarg2) {
  void * jresult ;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  std::vector< Date > *arg2 = 0 ;
  TimeBasket result;
  
  arg1 = (TimeBasket *)jarg1; 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((TimeBasket const *)arg1)->rebin((std::vector< Date > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeBasket((const TimeBasket &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TimeBasket(void * jarg1) {
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  
  arg1 = (TimeBasket *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Swap(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< CashFlow > > *arg2 = 0 ;
  SwapPtr *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< CashFlow > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CashFlow > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapPtr *)new_SwapPtr((std::vector< boost::shared_ptr< CashFlow > > const &)*arg1,(std::vector< boost::shared_ptr< CashFlow > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Swap_startDate(void * jarg1) {
  void * jresult ;
  SwapPtr *arg1 = (SwapPtr *) 0 ;
  Date result;
  
  arg1 = (SwapPtr *)jarg1; 
  {
    try {
      result = SwapPtr_startDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Swap_maturityDate(void * jarg1) {
  void * jresult ;
  SwapPtr *arg1 = (SwapPtr *) 0 ;
  Date result;
  
  arg1 = (SwapPtr *)jarg1; 
  {
    try {
      result = SwapPtr_maturityDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Swap_leg(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  SwapPtr *arg1 = (SwapPtr *) 0 ;
  Size arg2 ;
  Leg *result = 0 ;
  
  arg1 = (SwapPtr *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Leg *) &SwapPtr_leg(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Swap_legNPV(void * jarg1, unsigned long jarg2) {
  double jresult ;
  SwapPtr *arg1 = (SwapPtr *) 0 ;
  Size arg2 ;
  Real result;
  
  arg1 = (SwapPtr *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)SwapPtr_legNPV((SwapPtr const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Swap(void * jarg1) {
  SwapPtr *arg1 = (SwapPtr *) 0 ;
  
  arg1 = (SwapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__VanillaSwap(void * jarg1) {
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  
  arg1 = (VanillaSwap *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_VanillaSwap_Receiver_get() {
  int jresult ;
  enum VanillaSwap::Type result;
  
  result = (enum VanillaSwap::Type)VanillaSwap::Receiver;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_VanillaSwap_Payer_get() {
  int jresult ;
  enum VanillaSwap::Type result;
  
  result = (enum VanillaSwap::Type)VanillaSwap::Payer;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VanillaSwap(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Spread arg8 ;
  DayCounter *arg9 = 0 ;
  VanillaSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (VanillaSwapPtr *)new_VanillaSwapPtr(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(IborIndexPtr const &)*arg7,arg8,(DayCounter const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_fairRate(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Rate result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Rate)VanillaSwapPtr_fairRate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_fairSpread(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Spread result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Spread)VanillaSwapPtr_fairSpread(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_fixedLegBPS(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaSwapPtr_fixedLegBPS(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_floatingLegBPS(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaSwapPtr_floatingLegBPS(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_fixedLegNPV(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaSwapPtr_fixedLegNPV(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_floatingLegNPV(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaSwapPtr_floatingLegNPV(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_VanillaSwap_fixedLeg(void * jarg1) {
  void * jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Leg *result = 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Leg *) &VanillaSwapPtr_fixedLeg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_VanillaSwap_floatingLeg(void * jarg1) {
  void * jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Leg *result = 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Leg *) &VanillaSwapPtr_floatingLeg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_nominal(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Real result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Real)VanillaSwapPtr_nominal(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_VanillaSwap_fixedSchedule(void * jarg1) {
  void * jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Schedule *result = 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Schedule *) &VanillaSwapPtr_fixedSchedule(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_VanillaSwap_floatingSchedule(void * jarg1) {
  void * jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Schedule *result = 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Schedule *) &VanillaSwapPtr_floatingSchedule(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_fixedRate(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Rate result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Rate)VanillaSwapPtr_fixedRate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_VanillaSwap_spread(void * jarg1) {
  double jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  Spread result;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (Spread)VanillaSwapPtr_spread(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_VanillaSwap_floatingDayCount(void * jarg1) {
  void * jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  DayCounter *result = 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (DayCounter *) &VanillaSwapPtr_floatingDayCount(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_VanillaSwap_fixedDayCount(void * jarg1) {
  void * jresult ;
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  DayCounter *result = 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      result = (DayCounter *) &VanillaSwapPtr_fixedDayCount(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VanillaSwap(void * jarg1) {
  VanillaSwapPtr *arg1 = (VanillaSwapPtr *) 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__NonstandardSwap(void * jarg1) {
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  
  arg1 = (NonstandardSwap *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonstandardSwap__SWIG_0(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, unsigned int jarg13, int jarg14) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  IborIndexPtr *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  bool arg13 ;
  BusinessDayConvention arg14 ;
  NonstandardSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (IborIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = (BusinessDayConvention)jarg14; 
  {
    try {
      result = (NonstandardSwapPtr *)new_NonstandardSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(IborIndexPtr const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(DayCounter const &)*arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonstandardSwap__SWIG_1(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  IborIndexPtr *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  bool arg13 ;
  NonstandardSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (IborIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (NonstandardSwapPtr *)new_NonstandardSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(IborIndexPtr const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(DayCounter const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonstandardSwap__SWIG_2(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  IborIndexPtr *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  NonstandardSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (IborIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (NonstandardSwapPtr *)new_NonstandardSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(IborIndexPtr const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(DayCounter const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonstandardSwap__SWIG_3(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  IborIndexPtr *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  NonstandardSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (IborIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & type is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (NonstandardSwapPtr *)new_NonstandardSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(IborIndexPtr const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(DayCounter const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_fixedLeg(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  Leg *result = 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = (Leg *) &NonstandardSwapPtr_fixedLeg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_floatingLeg(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  Leg *result = 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = (Leg *) &NonstandardSwapPtr_floatingLeg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_fixedNominals(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  std::vector< Real > result;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = NonstandardSwapPtr_fixedNominals(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_floatingNominals(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  std::vector< Real > result;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = NonstandardSwapPtr_floatingNominals(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_fixedSchedule(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  Schedule *result = 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = (Schedule *) &NonstandardSwapPtr_fixedSchedule(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_floatingSchedule(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  Schedule *result = 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = (Schedule *) &NonstandardSwapPtr_floatingSchedule(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_fixedRate(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  std::vector< Rate > result;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = NonstandardSwapPtr_fixedRate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Rate >((const std::vector< Rate > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_spreads(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  std::vector< Spread > result;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = NonstandardSwapPtr_spreads(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Spread >((const std::vector< Spread > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_gearings(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  std::vector< Spread > result;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = NonstandardSwapPtr_gearings(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Spread >((const std::vector< Spread > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_floatingDayCount(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  DayCounter *result = 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = (DayCounter *) &NonstandardSwapPtr_floatingDayCount(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_fixedDayCount(void * jarg1) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  DayCounter *result = 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      result = (DayCounter *) &NonstandardSwapPtr_fixedDayCount(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NonstandardSwap(void * jarg1) {
  NonstandardSwapPtr *arg1 = (NonstandardSwapPtr *) 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DiscountingSwapEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEnginePtr *)new_DiscountingSwapEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Date *arg2 = 0 ;
  DiscountingSwapEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEnginePtr *)new_DiscountingSwapEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_2(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  DiscountingSwapEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEnginePtr *)new_DiscountingSwapEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_3(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  DiscountingSwapEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEnginePtr *)new_DiscountingSwapEnginePtr__SWIG_3((Handle< YieldTermStructure > const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_4(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  DiscountingSwapEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEnginePtr *)new_DiscountingSwapEnginePtr__SWIG_3((Handle< YieldTermStructure > const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  DiscountingSwapEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (DiscountingSwapEnginePtr *)new_DiscountingSwapEnginePtr__SWIG_3((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DiscountingSwapEngine(void * jarg1) {
  DiscountingSwapEnginePtr *arg1 = (DiscountingSwapEnginePtr *) 0 ;
  
  arg1 = (DiscountingSwapEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AssetSwap__SWIG_0(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, double jarg5, void * jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  bool arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  InterestRateIndexPtr *arg4 = 0 ;
  Spread arg5 ;
  Schedule *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  AssetSwapPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (InterestRateIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Spread)jarg5; 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (AssetSwapPtr *)new_AssetSwapPtr__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(InterestRateIndexPtr const &)*arg4,arg5,(Schedule const &)*arg6,(DayCounter const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AssetSwap__SWIG_1(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, double jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  bool arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  InterestRateIndexPtr *arg4 = 0 ;
  Spread arg5 ;
  Schedule *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  AssetSwapPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (InterestRateIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Spread)jarg5; 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AssetSwapPtr *)new_AssetSwapPtr__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(InterestRateIndexPtr const &)*arg4,arg5,(Schedule const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AssetSwap__SWIG_2(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, double jarg5, void * jarg6) {
  void * jresult ;
  bool arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  InterestRateIndexPtr *arg4 = 0 ;
  Spread arg5 ;
  Schedule *arg6 = 0 ;
  AssetSwapPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (InterestRateIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Spread)jarg5; 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (AssetSwapPtr *)new_AssetSwapPtr__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(InterestRateIndexPtr const &)*arg4,arg5,(Schedule const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AssetSwap__SWIG_3(unsigned int jarg1, void * jarg2, double jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  bool arg1 ;
  BondPtr *arg2 = 0 ;
  Real arg3 ;
  InterestRateIndexPtr *arg4 = 0 ;
  Spread arg5 ;
  AssetSwapPtr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (InterestRateIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Spread)jarg5; 
  {
    try {
      result = (AssetSwapPtr *)new_AssetSwapPtr__SWIG_0(arg1,(BondPtr const &)*arg2,arg3,(InterestRateIndexPtr const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AssetSwap_fairCleanPrice(void * jarg1) {
  double jresult ;
  AssetSwapPtr *arg1 = (AssetSwapPtr *) 0 ;
  Real result;
  
  arg1 = (AssetSwapPtr *)jarg1; 
  {
    try {
      result = (Real)AssetSwapPtr_fairCleanPrice(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AssetSwap_fairSpread(void * jarg1) {
  double jresult ;
  AssetSwapPtr *arg1 = (AssetSwapPtr *) 0 ;
  Spread result;
  
  arg1 = (AssetSwapPtr *)jarg1; 
  {
    try {
      result = (Spread)AssetSwapPtr_fairSpread(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AssetSwap(void * jarg1) {
  AssetSwapPtr *arg1 = (AssetSwapPtr *) 0 ;
  
  arg1 = (AssetSwapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_0(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15, void * jarg16, void * jarg17, void * jarg18, void * jarg19, int jarg20, int jarg21) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  std::vector< Real > *arg15 = 0 ;
  std::vector< Real > *arg16 = 0 ;
  std::vector< Real > *arg17 = 0 ;
  std::vector< Real > *arg18 = 0 ;
  std::vector< Real > *arg19 = 0 ;
  BusinessDayConvention arg20 ;
  BusinessDayConvention arg21 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg19 = (std::vector< Real > *)jarg19;
  if (!arg19) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg20 = (BusinessDayConvention)jarg20; 
  arg21 = (BusinessDayConvention)jarg21; 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13,(std::vector< double > const &)*arg14,(std::vector< double > const &)*arg15,(std::vector< double > const &)*arg16,(std::vector< double > const &)*arg17,(std::vector< double > const &)*arg18,(std::vector< double > const &)*arg19,arg20,arg21);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_1(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15, void * jarg16, void * jarg17, void * jarg18, void * jarg19, int jarg20) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  std::vector< Real > *arg15 = 0 ;
  std::vector< Real > *arg16 = 0 ;
  std::vector< Real > *arg17 = 0 ;
  std::vector< Real > *arg18 = 0 ;
  std::vector< Real > *arg19 = 0 ;
  BusinessDayConvention arg20 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg19 = (std::vector< Real > *)jarg19;
  if (!arg19) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg20 = (BusinessDayConvention)jarg20; 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13,(std::vector< double > const &)*arg14,(std::vector< double > const &)*arg15,(std::vector< double > const &)*arg16,(std::vector< double > const &)*arg17,(std::vector< double > const &)*arg18,(std::vector< double > const &)*arg19,arg20);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_2(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15, void * jarg16, void * jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  std::vector< Real > *arg15 = 0 ;
  std::vector< Real > *arg16 = 0 ;
  std::vector< Real > *arg17 = 0 ;
  std::vector< Real > *arg18 = 0 ;
  std::vector< Real > *arg19 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg19 = (std::vector< Real > *)jarg19;
  if (!arg19) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13,(std::vector< double > const &)*arg14,(std::vector< double > const &)*arg15,(std::vector< double > const &)*arg16,(std::vector< double > const &)*arg17,(std::vector< double > const &)*arg18,(std::vector< double > const &)*arg19);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_3(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15, void * jarg16, void * jarg17, void * jarg18) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  std::vector< Real > *arg15 = 0 ;
  std::vector< Real > *arg16 = 0 ;
  std::vector< Real > *arg17 = 0 ;
  std::vector< Real > *arg18 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13,(std::vector< double > const &)*arg14,(std::vector< double > const &)*arg15,(std::vector< double > const &)*arg16,(std::vector< double > const &)*arg17,(std::vector< double > const &)*arg18);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_4(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15, void * jarg16, void * jarg17) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  std::vector< Real > *arg15 = 0 ;
  std::vector< Real > *arg16 = 0 ;
  std::vector< Real > *arg17 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13,(std::vector< double > const &)*arg14,(std::vector< double > const &)*arg15,(std::vector< double > const &)*arg16,(std::vector< double > const &)*arg17);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15, void * jarg16) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  std::vector< Real > *arg15 = 0 ;
  std::vector< Real > *arg16 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13,(std::vector< double > const &)*arg14,(std::vector< double > const &)*arg15,(std::vector< double > const &)*arg16);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  std::vector< Real > *arg15 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13,(std::vector< double > const &)*arg14,(std::vector< double > const &)*arg15);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13,(std::vector< double > const &)*arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12,(std::vector< double > const &)*arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, void * jarg12) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< double > const &)*arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_10(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_11(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwap__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  VanillaSwap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  InterestRateIndexPtr *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  InterestRateIndexPtr *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  FloatFloatSwapPtr *result = 0 ;
  
  arg1 = (VanillaSwap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (InterestRateIndexPtr *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg8 = (InterestRateIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRateIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwapPtr *)new_FloatFloatSwapPtr__SWIG_0(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,(Schedule const &)*arg4,(InterestRateIndexPtr const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(InterestRateIndexPtr const &)*arg8,(DayCounter const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloatFloatSwap(void * jarg1) {
  FloatFloatSwapPtr *arg1 = (FloatFloatSwapPtr *) 0 ;
  
  arg1 = (FloatFloatSwapPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Pillar() {
  void * jresult ;
  Pillar *result = 0 ;
  
  {
    try {
      result = (Pillar *)new Pillar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Pillar(void * jarg1) {
  Pillar *arg1 = (Pillar *) 0 ;
  
  arg1 = (Pillar *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelper___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RateHelper > *arg1 = (boost::shared_ptr< RateHelper > *) 0 ;
  RateHelper *result = 0 ;
  
  arg1 = (boost::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = (RateHelper *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_RateHelper_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< RateHelper > *arg1 = (boost::shared_ptr< RateHelper > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_RateHelper_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RateHelper() {
  void * jresult ;
  boost::shared_ptr< RateHelper > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< RateHelper > *)new boost::shared_ptr< RateHelper >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RateHelper(void * jarg1) {
  boost::shared_ptr< RateHelper > *arg1 = (boost::shared_ptr< RateHelper > *) 0 ;
  
  arg1 = (boost::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelper_quote(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RateHelper > *arg1 = (boost::shared_ptr< RateHelper > *) 0 ;
  Handle< Quote > result;
  
  arg1 = (boost::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = (*arg1)->quote();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Handle< Quote >((const Handle< Quote > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelper_latestDate(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RateHelper > *arg1 = (boost::shared_ptr< RateHelper > *) 0 ;
  Date result;
  
  arg1 = (boost::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = (*arg1)->latestDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DepositRateHelper__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  DepositRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DepositRateHelperPtr *)new_DepositRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DepositRateHelper__SWIG_1(double jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  DepositRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DepositRateHelperPtr *)new_DepositRateHelperPtr__SWIG_1(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DepositRateHelper__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  DepositRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DepositRateHelperPtr *)new_DepositRateHelperPtr__SWIG_2((Handle< Quote > const &)*arg1,(IborIndexPtr const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DepositRateHelper__SWIG_3(double jarg1, void * jarg2) {
  void * jresult ;
  Rate arg1 ;
  IborIndexPtr *arg2 = 0 ;
  DepositRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DepositRateHelperPtr *)new_DepositRateHelperPtr__SWIG_3(arg1,(IborIndexPtr const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DepositRateHelper(void * jarg1) {
  DepositRateHelperPtr *arg1 = (DepositRateHelperPtr *) 0 ;
  
  arg1 = (DepositRateHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  FraRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = (Natural)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FraRateHelperPtr *)new_FraRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_1(double jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  FraRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = (Natural)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FraRateHelperPtr *)new_FraRateHelperPtr__SWIG_1(arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_2(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  IborIndexPtr *arg3 = 0 ;
  FraRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FraRateHelperPtr *)new_FraRateHelperPtr__SWIG_2((Handle< Quote > const &)*arg1,arg2,(IborIndexPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_3(double jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  IborIndexPtr *arg3 = 0 ;
  FraRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FraRateHelperPtr *)new_FraRateHelperPtr__SWIG_3(arg1,arg2,(IborIndexPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FraRateHelper(void * jarg1) {
  FraRateHelperPtr *arg1 = (FraRateHelperPtr *) 0 ;
  
  arg1 = (FraRateHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Futures::Type arg9 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Futures::Type)jarg9; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7,(Handle< Quote > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7,(Handle< Quote > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_2(double jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, double jarg8, int jarg9) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  Futures::Type arg9 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = (Futures::Type)jarg9; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_2(arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_3(double jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_2(arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_4(double jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_2(arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Futures::Type arg6 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg6 = (Futures::Type)jarg6; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_5((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,(Handle< Quote > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_5((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,(Handle< Quote > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_7(double jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, int jarg6) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Rate arg5 ;
  Futures::Type arg6 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Rate)jarg5; 
  arg6 = (Futures::Type)jarg6; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_7(arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_8(double jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Rate arg5 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (Rate)jarg5; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_7(arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_9(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_7(arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Futures::Type arg5 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg5 = (Futures::Type)jarg5; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_10((Handle< Quote > const &)*arg1,(Date const &)*arg2,(IborIndexPtr const &)*arg3,(Handle< Quote > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_10((Handle< Quote > const &)*arg1,(Date const &)*arg2,(IborIndexPtr const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_12(double jarg1, void * jarg2, void * jarg3, double jarg4, int jarg5) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  Real arg4 ;
  Futures::Type arg5 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Futures::Type)jarg5; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_12(arg1,(Date const &)*arg2,(IborIndexPtr const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_13(double jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  Real arg4 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_12(arg1,(Date const &)*arg2,(IborIndexPtr const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_14(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  IborIndexPtr *arg3 = 0 ;
  FuturesRateHelperPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (IborIndexPtr *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelperPtr *)new_FuturesRateHelperPtr__SWIG_12(arg1,(Date const &)*arg2,(IborIndexPtr const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FuturesRateHelper(void * jarg1) {
  FuturesRateHelperPtr *arg1 = (FuturesRateHelperPtr *) 0 ;
  
  arg1 = (FuturesRateHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_0(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11, int jarg12, void * jarg13) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  Date *argp13 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  arg12 = (Pillar::Choice)jarg12; 
  argp13 = (Date *)jarg13; 
  if (!argp13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg13 = *argp13; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11, int jarg12) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  arg12 = (Pillar::Choice)jarg12; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_2(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_3(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_4(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_5(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_6(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_7(double jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11, int jarg12, void * jarg13) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  Date *argp13 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  arg12 = (Pillar::Choice)jarg12; 
  argp13 = (Date *)jarg13; 
  if (!argp13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg13 = *argp13; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_7(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_8(double jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11, int jarg12) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  arg12 = (Pillar::Choice)jarg12; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_7(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_9(double jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_7(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_10(double jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_7(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_11(double jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_7(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_12(double jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_7(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7,(Handle< Quote > const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_13(double jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  IborIndexPtr *arg7 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (IborIndexPtr *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_7(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(IborIndexPtr const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_14(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  Date *argp7 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (Pillar::Choice)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_14((Handle< Quote > const &)*arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_15(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (Pillar::Choice)jarg6; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_14((Handle< Quote > const &)*arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_16(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_14((Handle< Quote > const &)*arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_17(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_14((Handle< Quote > const &)*arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_18(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_14((Handle< Quote > const &)*arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_19(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  SwapIndexPtr *arg2 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_14((Handle< Quote > const &)*arg1,(SwapIndexPtr const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_20(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7) {
  void * jresult ;
  Rate arg1 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  Date *argp7 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (Pillar::Choice)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_20(arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_21(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Rate arg1 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (Pillar::Choice)jarg6; 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_20(arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_22(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Rate arg1 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_20(arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_23(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Rate arg1 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_20(arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_24(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Rate arg1 ;
  SwapIndexPtr *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_20(arg1,(SwapIndexPtr const &)*arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_25(double jarg1, void * jarg2) {
  void * jresult ;
  Rate arg1 ;
  SwapIndexPtr *arg2 = 0 ;
  SwapRateHelperPtr *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (SwapIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelperPtr *)new_SwapRateHelperPtr__SWIG_20(arg1,(SwapIndexPtr const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapRateHelper_swap(void * jarg1) {
  void * jresult ;
  SwapRateHelperPtr *arg1 = (SwapRateHelperPtr *) 0 ;
  SwigValueWrapper< VanillaSwapPtr > result;
  
  arg1 = (SwapRateHelperPtr *)jarg1; 
  {
    try {
      result = SwapRateHelperPtr_swap(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new VanillaSwapPtr((const VanillaSwapPtr &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwapRateHelper(void * jarg1) {
  SwapRateHelperPtr *arg1 = (SwapRateHelperPtr *) 0 ;
  
  arg1 = (SwapRateHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondHelper__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  BondPtr *arg2 = 0 ;
  bool arg3 ;
  BondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (BondHelperPtr *)new_BondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(BondPtr const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondHelper__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  BondPtr *arg2 = 0 ;
  BondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (BondPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BondHelperPtr *)new_BondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(BondPtr const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondHelper_bond(void * jarg1) {
  void * jresult ;
  BondHelperPtr *arg1 = (BondHelperPtr *) 0 ;
  SwigValueWrapper< BondPtr > result;
  
  arg1 = (BondHelperPtr *)jarg1; 
  {
    try {
      result = BondHelperPtr_bond(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new BondPtr((const BondPtr &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BondHelper(void * jarg1) {
  BondHelperPtr *arg1 = (BondHelperPtr *) 0 ;
  
  arg1 = (BondHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_0(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  BusinessDayConvention arg13 ;
  bool arg14 ;
  bool arg15 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg13 = (BusinessDayConvention)jarg13; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_1(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, int jarg13, unsigned int jarg14) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  BusinessDayConvention arg13 ;
  bool arg14 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg13 = (BusinessDayConvention)jarg13; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_2(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, int jarg13) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  BusinessDayConvention arg13 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg13 = (BusinessDayConvention)jarg13; 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_3(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_4(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_5(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_6(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_7(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_8(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondHelper__SWIG_9(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  FixedRateBondHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelperPtr *)new_FixedRateBondHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateBondHelper_bond(void * jarg1) {
  void * jresult ;
  FixedRateBondHelperPtr *arg1 = (FixedRateBondHelperPtr *) 0 ;
  SwigValueWrapper< FixedRateBondPtr > result;
  
  arg1 = (FixedRateBondHelperPtr *)jarg1; 
  {
    try {
      result = FixedRateBondHelperPtr_bond(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FixedRateBondPtr((const FixedRateBondPtr &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedRateBondHelper(void * jarg1) {
  FixedRateBondHelperPtr *arg1 = (FixedRateBondHelperPtr *) 0 ;
  
  arg1 = (FixedRateBondHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_0(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, unsigned int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11, double jarg12) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Natural arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Spread arg12 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Natural)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg12 = (Spread)jarg12; 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_1(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, unsigned int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Natural arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Natural)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_2(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, unsigned int jarg7, int jarg8, int jarg9, void * jarg10) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Natural arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Natural)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_3(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, unsigned int jarg7, int jarg8, int jarg9) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Natural arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Natural)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_4(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, unsigned int jarg7, int jarg8) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Natural arg7 ;
  BusinessDayConvention arg8 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Natural)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_5(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, unsigned int jarg7) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Natural arg7 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Natural)jarg7; 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_6(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_7(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_8(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  OISRateHelperPtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (OISRateHelperPtr *)new_OISRateHelperPtr__SWIG_0(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OISRateHelper(void * jarg1) {
  OISRateHelperPtr *arg1 = (OISRateHelperPtr *) 0 ;
  
  arg1 = (OISRateHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  DatedOISRateHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DatedOISRateHelperPtr *)new_DatedOISRateHelperPtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  OvernightIndexPtr *arg4 = 0 ;
  DatedOISRateHelperPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg4 = (OvernightIndexPtr *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OvernightIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (DatedOISRateHelperPtr *)new_DatedOISRateHelperPtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(OvernightIndexPtr const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DatedOISRateHelper(void * jarg1) {
  DatedOISRateHelperPtr *arg1 = (DatedOISRateHelperPtr *) 0 ;
  
  arg1 = (DatedOISRateHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FxSwapRateHelper__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, unsigned int jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Period *arg3 = 0 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  bool arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  FxSwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Natural)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FxSwapRateHelperPtr *)new_FxSwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Handle< Quote > const &)*arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,(Calendar const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FxSwapRateHelper__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, unsigned int jarg8, void * jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Period *arg3 = 0 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  bool arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  FxSwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Natural)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FxSwapRateHelperPtr *)new_FxSwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Handle< Quote > const &)*arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(Handle< YieldTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FxSwapRateHelper__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, unsigned int jarg8) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Period *arg3 = 0 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  bool arg8 ;
  FxSwapRateHelperPtr *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Natural)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (FxSwapRateHelperPtr *)new_FxSwapRateHelperPtr__SWIG_0((Handle< Quote > const &)*arg1,(Handle< Quote > const &)*arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FxSwapRateHelper(void * jarg1) {
  FxSwapRateHelperPtr *arg1 = (FxSwapRateHelperPtr *) 0 ;
  
  arg1 = (FxSwapRateHelperPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  boost::shared_ptr< RateHelper > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< RateHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< RateHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((boost::shared_ptr< RateHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_RateHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  std::vector< boost::shared_ptr< RateHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< RateHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_RateHelperVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  std::vector< boost::shared_ptr< RateHelper > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< boost::shared_ptr< RateHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  std::vector< boost::shared_ptr< RateHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > >::size_type)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RateHelperVector__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< boost::shared_ptr< RateHelper > > *)new std::vector< boost::shared_ptr< RateHelper > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RateHelperVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< boost::shared_ptr< RateHelper > > *)new std::vector< boost::shared_ptr< RateHelper > >((std::vector< boost::shared_ptr< RateHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RateHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RateHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< RateHelper > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg___SWIG_2(arg1);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RateHelper > result;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__getitemcopy(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< RateHelper >((const boost::shared_ptr< RateHelper > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RateHelper > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (boost::shared_ptr< RateHelper > *) &std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__getitem(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RateHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< RateHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< RateHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RateHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RateHelper > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< RateHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__GetRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RateHelper > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (boost::shared_ptr< RateHelper > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< RateHelper > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RateHelper > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__RemoveAt(arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__RemoveRange(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RateHelper > *arg1 = 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RateHelper > > *result = 0 ;
  
  arg1 = (boost::shared_ptr< RateHelper > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< RateHelper > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< boost::shared_ptr< RateHelper > > *)std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Repeat((boost::shared_ptr< RateHelper > const &)*arg1,arg2);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return 0;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Reverse__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      catch(std::invalid_argument &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3);
      }
      catch(std::out_of_range &_e) {
        SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
        return ;
      }
      
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_RateHelperVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  boost::shared_ptr< RateHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< RateHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< RateHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Contains(arg1,(boost::shared_ptr< RateHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_RateHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  boost::shared_ptr< RateHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< RateHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< RateHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__IndexOf(arg1,(boost::shared_ptr< RateHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_RateHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  boost::shared_ptr< RateHelper > *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< RateHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< RateHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__LastIndexOf(arg1,(boost::shared_ptr< RateHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_RateHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  boost::shared_ptr< RateHelper > *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (boost::shared_ptr< RateHelper > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< RateHelper > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_boost_shared_ptr_Sl_RateHelper_Sg__Sg__Remove(arg1,(boost::shared_ptr< RateHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RateHelperVector(void * jarg1) {
  std::vector< boost::shared_ptr< RateHelper > > *arg1 = (std::vector< boost::shared_ptr< RateHelper > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FittingMethod(void * jarg1) {
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  
  arg1 = (FittingMethod *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_FittingMethod_size(void * jarg1) {
  unsigned long jresult ;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  Size result;
  
  arg1 = (FittingMethod *)jarg1; 
  {
    try {
      result = ((FittingMethod const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FittingMethod_solution(void * jarg1) {
  void * jresult ;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  Array result;
  
  arg1 = (FittingMethod *)jarg1; 
  {
    try {
      result = ((FittingMethod const *)arg1)->solution();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_FittingMethod_numberOfIterations(void * jarg1) {
  int jresult ;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  Integer result;
  
  arg1 = (FittingMethod *)jarg1; 
  {
    try {
      result = (Integer)((FittingMethod const *)arg1)->numberOfIterations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FittingMethod_minimumCostValue(void * jarg1) {
  double jresult ;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  Real result;
  
  arg1 = (FittingMethod *)jarg1; 
  {
    try {
      result = (Real)((FittingMethod const *)arg1)->minimumCostValue();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_FittingMethod_constrainAtZero(void * jarg1) {
  unsigned int jresult ;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  bool result;
  
  arg1 = (FittingMethod *)jarg1; 
  {
    try {
      result = (bool)((FittingMethod const *)arg1)->constrainAtZero();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FittingMethod_weights(void * jarg1) {
  void * jresult ;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  Array result;
  
  arg1 = (FittingMethod *)jarg1; 
  {
    try {
      result = ((FittingMethod const *)arg1)->weights();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_0(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, unsigned long jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  Array *arg8 = 0 ;
  Real arg9 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (FittingMethod *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Array *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_0(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5,arg6,arg7,(Array const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_1(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, unsigned long jarg7, void * jarg8) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  Array *arg8 = 0 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (FittingMethod *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Array *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_0(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5,arg6,arg7,(Array const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_2(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, unsigned long jarg7) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (FittingMethod *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_0(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_3(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (FittingMethod *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_0(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_4(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (FittingMethod *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_0(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Array *arg7 = 0 ;
  Real arg8 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (FittingMethod *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Array *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_5((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4,arg5,arg6,(Array const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Array *arg7 = 0 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (FittingMethod *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Array *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_5((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4,arg5,arg6,(Array const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (FittingMethod *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_5((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_8(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (FittingMethod *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_5((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FittedBondDiscountCurve__SWIG_9(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  FittedBondDiscountCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (FittingMethod *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FittedBondDiscountCurvePtr *)new_FittedBondDiscountCurvePtr__SWIG_5((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FittedBondDiscountCurve_fitResults(void * jarg1) {
  void * jresult ;
  FittedBondDiscountCurvePtr *arg1 = (FittedBondDiscountCurvePtr *) 0 ;
  FittingMethod *result = 0 ;
  
  arg1 = (FittedBondDiscountCurvePtr *)jarg1; 
  {
    try {
      result = (FittingMethod *) &FittedBondDiscountCurvePtr_fitResults((FittedBondDiscountCurvePtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FittedBondDiscountCurve(void * jarg1) {
  FittedBondDiscountCurvePtr *arg1 = (FittedBondDiscountCurvePtr *) 0 ;
  
  arg1 = (FittedBondDiscountCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Array *arg2 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  ExponentialSplinesFitting *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_2() {
  void * jresult ;
  ExponentialSplinesFitting *result = 0 ;
  
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExponentialSplinesFitting(void * jarg1) {
  ExponentialSplinesFitting *arg1 = (ExponentialSplinesFitting *) 0 ;
  
  arg1 = (ExponentialSplinesFitting *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NelsonSiegelFitting__SWIG_0(void * jarg1) {
  void * jresult ;
  Array *arg1 = 0 ;
  NelsonSiegelFitting *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (NelsonSiegelFitting *)new NelsonSiegelFitting((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NelsonSiegelFitting__SWIG_1() {
  void * jresult ;
  NelsonSiegelFitting *result = 0 ;
  
  {
    try {
      result = (NelsonSiegelFitting *)new NelsonSiegelFitting();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NelsonSiegelFitting(void * jarg1) {
  NelsonSiegelFitting *arg1 = (NelsonSiegelFitting *) 0 ;
  
  arg1 = (NelsonSiegelFitting *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SvenssonFitting__SWIG_0(void * jarg1) {
  void * jresult ;
  Array *arg1 = 0 ;
  SvenssonFitting *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SvenssonFitting *)new SvenssonFitting((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SvenssonFitting__SWIG_1() {
  void * jresult ;
  SvenssonFitting *result = 0 ;
  
  {
    try {
      result = (SvenssonFitting *)new SvenssonFitting();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SvenssonFitting(void * jarg1) {
  SvenssonFitting *arg1 = (SvenssonFitting *) 0 ;
  
  arg1 = (SvenssonFitting *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicBSplinesFitting__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  bool arg2 ;
  Array *arg3 = 0 ;
  CubicBSplinesFitting *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CubicBSplinesFitting *)new CubicBSplinesFitting((std::vector< Time > const &)*arg1,arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicBSplinesFitting__SWIG_1(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  bool arg2 ;
  CubicBSplinesFitting *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (CubicBSplinesFitting *)new CubicBSplinesFitting((std::vector< Time > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicBSplinesFitting__SWIG_2(void * jarg1) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  CubicBSplinesFitting *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CubicBSplinesFitting *)new CubicBSplinesFitting((std::vector< Time > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CubicBSplinesFitting_basisFunction(void * jarg1, int jarg2, double jarg3) {
  double jresult ;
  CubicBSplinesFitting *arg1 = (CubicBSplinesFitting *) 0 ;
  Integer arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (CubicBSplinesFitting *)jarg1; 
  arg2 = (Integer)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(arg1)->basisFunction(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CubicBSplinesFitting(void * jarg1) {
  CubicBSplinesFitting *arg1 = (CubicBSplinesFitting *) 0 ;
  
  arg1 = (CubicBSplinesFitting *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SimplePolynomialFitting__SWIG_0(unsigned int jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Natural arg1 ;
  bool arg2 ;
  Array *arg3 = 0 ;
  SimplePolynomialFitting *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SimplePolynomialFitting *)new SimplePolynomialFitting(arg1,arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SimplePolynomialFitting__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
  void * jresult ;
  Natural arg1 ;
  bool arg2 ;
  SimplePolynomialFitting *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (SimplePolynomialFitting *)new SimplePolynomialFitting(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SimplePolynomialFitting__SWIG_2(unsigned int jarg1) {
  void * jresult ;
  Natural arg1 ;
  SimplePolynomialFitting *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  {
    try {
      result = (SimplePolynomialFitting *)new SimplePolynomialFitting(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SimplePolynomialFitting(void * jarg1) {
  SimplePolynomialFitting *arg1 = (SimplePolynomialFitting *) 0 ;
  
  arg1 = (SimplePolynomialFitting *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  ForwardCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardCurvePtr *)new_ForwardCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(BackwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  ForwardCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardCurvePtr *)new_ForwardCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  ForwardCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardCurvePtr *)new_ForwardCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardCurve_dates(void * jarg1) {
  void * jresult ;
  ForwardCurvePtr *arg1 = (ForwardCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (ForwardCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &ForwardCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardCurve_forwards(void * jarg1) {
  void * jresult ;
  ForwardCurvePtr *arg1 = (ForwardCurvePtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (ForwardCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &ForwardCurvePtr_forwards(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardCurve_nodes(void * jarg1) {
  void * jresult ;
  ForwardCurvePtr *arg1 = (ForwardCurvePtr *) 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  arg1 = (ForwardCurvePtr *)jarg1; 
  {
    try {
      result = ForwardCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Rate > >((const std::vector< std::pair< Date,Rate > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardCurve(void * jarg1) {
  ForwardCurvePtr *arg1 = (ForwardCurvePtr *) 0 ;
  
  arg1 = (ForwardCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Position() {
  void * jresult ;
  Position *result = 0 ;
  
  {
    try {
      result = (Position *)new Position();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Position(void * jarg1) {
  Position *arg1 = (Position *) 0 ;
  
  arg1 = (Position *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_0(void * jarg1, void * jarg2, int jarg3, double jarg4, double jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  IborIndexPtr *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  ForwardRateAgreementPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (IborIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardRateAgreementPtr *)new_ForwardRateAgreementPtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(IborIndexPtr const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_1(void * jarg1, void * jarg2, int jarg3, double jarg4, double jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  IborIndexPtr *arg6 = 0 ;
  ForwardRateAgreementPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (IborIndexPtr *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardRateAgreementPtr *)new_ForwardRateAgreementPtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(IborIndexPtr const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ForwardRateAgreement_spotIncome(void * jarg1, void * jarg2) {
  double jresult ;
  ForwardRateAgreementPtr *arg1 = (ForwardRateAgreementPtr *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Real result;
  
  arg1 = (ForwardRateAgreementPtr *)jarg1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)ForwardRateAgreementPtr_spotIncome((ForwardRateAgreementPtr const *)arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ForwardRateAgreement_spotValue(void * jarg1) {
  double jresult ;
  ForwardRateAgreementPtr *arg1 = (ForwardRateAgreementPtr *) 0 ;
  Real result;
  
  arg1 = (ForwardRateAgreementPtr *)jarg1; 
  {
    try {
      result = (Real)ForwardRateAgreementPtr_spotValue((ForwardRateAgreementPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardRateAgreement_forwardRate(void * jarg1) {
  void * jresult ;
  ForwardRateAgreementPtr *arg1 = (ForwardRateAgreementPtr *) 0 ;
  InterestRate result;
  
  arg1 = (ForwardRateAgreementPtr *)jarg1; 
  {
    try {
      result = ForwardRateAgreementPtr_forwardRate((ForwardRateAgreementPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardRateAgreement(void * jarg1) {
  ForwardRateAgreementPtr *arg1 = (ForwardRateAgreementPtr *) 0 ;
  
  arg1 = (ForwardRateAgreementPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Gaussian1dModel *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  {
    try {
      result = (Gaussian1dModel *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_Gaussian1dModel_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dModel() {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< Gaussian1dModel > *)new boost::shared_ptr< Gaussian1dModel >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dModel(void * jarg1) {
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_stateProcess(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  SwigValueWrapper< StochasticProcess1DPtr > result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  {
    try {
      result = (*arg1)->stateProcess();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new StochasticProcess1DPtr((const StochasticProcess1DPtr &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_numeraire__SWIG_0(void * jarg1, double jarg2, double jarg3, void * jarg4) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->numeraire(arg2,arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_numeraire__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(*arg1)->numeraire(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_numeraire__SWIG_2(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(*arg1)->numeraire(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_numeraire__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->numeraire((Date const &)*arg2,arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_numeraire__SWIG_4(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)(*arg1)->numeraire((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_numeraire__SWIG_5(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->numeraire((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobond__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4, void * jarg5) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->zerobond(arg2,arg3,arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobond__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)(*arg1)->zerobond(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobond__SWIG_2(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(*arg1)->zerobond(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobond__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(*arg1)->zerobond(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobond__SWIG_4(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->zerobond((Date const &)*arg2,(Date const &)*arg3,arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobond__SWIG_5(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)(*arg1)->zerobond((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobond__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->zerobond((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobond__SWIG_7(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->zerobond((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobondOption__SWIG_0(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7, double jarg8, void * jarg9, double jarg10, unsigned long jarg11, unsigned int jarg12, unsigned int jarg13) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Real arg10 ;
  Size arg11 ;
  bool arg12 ;
  bool arg13 ;
  Option::Type temp2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobondOption__SWIG_1(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7, double jarg8, void * jarg9, double jarg10, unsigned long jarg11, unsigned int jarg12) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Real arg10 ;
  Size arg11 ;
  bool arg12 ;
  Option::Type temp2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobondOption__SWIG_2(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7, double jarg8, void * jarg9, double jarg10, unsigned long jarg11) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Real arg10 ;
  Size arg11 ;
  Option::Type temp2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  {
    try {
      result = (Real)(*arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobondOption__SWIG_3(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7, double jarg8, void * jarg9, double jarg10) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Real arg10 ;
  Option::Type temp2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (Real)(*arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobondOption__SWIG_4(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7, double jarg8, void * jarg9) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobondOption__SWIG_5(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7, double jarg8) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Option::Type temp2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Real)(*arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobondOption__SWIG_6(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_zerobondOption__SWIG_7(void * jarg1, int jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Option::Type temp2 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  {
    try {
      result = (Real)(*arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_forwardRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  SwigValueWrapper< boost::shared_ptr< IborIndex > > arg5 ;
  boost::shared_ptr< IborIndex > *argp5 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  argp5 = (boost::shared_ptr< IborIndex > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< IborIndex >", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (Real)(*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_forwardRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)(*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_forwardRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_forwardRate__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->forwardRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_swapRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  SwigValueWrapper< boost::shared_ptr< SwapIndex > > arg6 ;
  boost::shared_ptr< SwapIndex > *argp6 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  argp6 = (boost::shared_ptr< SwapIndex > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< SwapIndex >", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (Real)(*arg1)->swapRate((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_swapRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)(*arg1)->swapRate((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_swapRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->swapRate((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_swapRate__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->swapRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_swapAnnuity__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  SwigValueWrapper< boost::shared_ptr< SwapIndex > > arg6 ;
  boost::shared_ptr< SwapIndex > *argp6 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  argp6 = (boost::shared_ptr< SwapIndex > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< SwapIndex >", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (Real)(*arg1)->swapAnnuity((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_swapAnnuity__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)(*arg1)->swapAnnuity((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_swapAnnuity__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->swapAnnuity((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_swapAnnuity__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = (boost::shared_ptr< Gaussian1dModel > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Real result;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->swapAnnuity((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gsr__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  Real arg5 ;
  GsrPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (GsrPtr *)new_GsrPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gsr__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  GsrPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GsrPtr *)new_GsrPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrateVolatilitiesIterative__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      GsrPtr_calibrateVolatilitiesIterative__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< double > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrateVolatilitiesIterative__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  {
    try {
      GsrPtr_calibrateVolatilitiesIterative__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrateVolatilitiesIterative__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  {
    try {
      GsrPtr_calibrateVolatilitiesIterative__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< bool > *arg7 = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return ;
  } 
  {
    try {
      GsrPtr_calibrate__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< double > const &)*arg6,(std::vector< bool > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      GsrPtr_calibrate__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< double > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  {
    try {
      GsrPtr_calibrate__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  {
    try {
      GsrPtr_calibrate__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Gsr_params_(void * jarg1) {
  void * jresult ;
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  Array result;
  
  arg1 = (GsrPtr *)jarg1; 
  {
    try {
      result = GsrPtr_params((GsrPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gsr_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  Array *arg2 = 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  Real result;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)GsrPtr_value(arg1,(Array const &)*arg2,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Gsr_endCriteria(void * jarg1) {
  int jresult ;
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  EndCriteria::Type result;
  
  arg1 = (GsrPtr *)jarg1; 
  {
    try {
      result = (EndCriteria::Type)GsrPtr_endCriteria((GsrPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_setParams(void * jarg1, void * jarg2) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      GsrPtr_setParams(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Gsr_functionEvaluation(void * jarg1) {
  int jresult ;
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  Integer result;
  
  arg1 = (GsrPtr *)jarg1; 
  {
    try {
      result = (Integer)GsrPtr_functionEvaluation((GsrPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Gsr_reversion(void * jarg1) {
  void * jresult ;
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  Array *result = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  {
    try {
      result = (Array *) &GsrPtr_reversion((GsrPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Gsr_volatility(void * jarg1) {
  void * jresult ;
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  Array *result = 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  {
    try {
      result = (Array *) &GsrPtr_volatility((GsrPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gsr(void * jarg1) {
  GsrPtr *arg1 = (GsrPtr *) 0 ;
  
  arg1 = (GsrPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__MarkovFunctional(void * jarg1) {
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  
  arg1 = (MarkovFunctional *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctionalSettings() {
  void * jresult ;
  MarkovFunctional::ModelSettings *result = 0 ;
  
  {
    try {
      result = (MarkovFunctional::ModelSettings *)new MarkovFunctional::ModelSettings();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MarkovFunctionalSettings(void * jarg1) {
  MarkovFunctional::ModelSettings *arg1 = (MarkovFunctional::ModelSettings *) 0 ;
  
  arg1 = (MarkovFunctional::ModelSettings *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_AdjustNone_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::AdjustNone;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_AdjustDigitals_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::AdjustDigitals;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_AdjustYts_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::AdjustYts;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_ExtrapolatePayoffFlat_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::ExtrapolatePayoffFlat;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_NoPayoffExtrapolation_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::NoPayoffExtrapolation;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_KahaleSmile_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::KahaleSmile;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_SmileExponentialExtrapolation_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::SmileExponentialExtrapolation;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_KahaleInterpolation_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::KahaleInterpolation;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_SmileDeleteArbitragePoints_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::SmileDeleteArbitragePoints;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_SabrSmile_get() {
  int jresult ;
  enum MarkovFunctional::ModelSettings::Adjustments result;
  
  result = (enum MarkovFunctional::ModelSettings::Adjustments)MarkovFunctional::ModelSettings::SabrSmile;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9, double jarg10, unsigned long jarg11, double jarg12, double jarg13, double jarg14, double jarg15, int jarg16, void * jarg17) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  Real arg10 ;
  Size arg11 ;
  Real arg12 ;
  Real arg13 ;
  Real arg14 ;
  Real arg15 ;
  int arg16 ;
  std::vector< Real > *arg17 = 0 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (Real)jarg12; 
  arg13 = (Real)jarg13; 
  arg14 = (Real)jarg14; 
  arg15 = (Real)jarg15; 
  arg16 = (int)jarg16; 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(std::vector< double > const &)*arg17);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9, double jarg10, unsigned long jarg11, double jarg12, double jarg13, double jarg14, double jarg15, int jarg16) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  Real arg10 ;
  Size arg11 ;
  Real arg12 ;
  Real arg13 ;
  Real arg14 ;
  Real arg15 ;
  int arg16 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (Real)jarg12; 
  arg13 = (Real)jarg13; 
  arg14 = (Real)jarg14; 
  arg15 = (Real)jarg15; 
  arg16 = (int)jarg16; 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9, double jarg10, unsigned long jarg11, double jarg12, double jarg13, double jarg14, double jarg15) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  Real arg10 ;
  Size arg11 ;
  Real arg12 ;
  Real arg13 ;
  Real arg14 ;
  Real arg15 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (Real)jarg12; 
  arg13 = (Real)jarg13; 
  arg14 = (Real)jarg14; 
  arg15 = (Real)jarg15; 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9, double jarg10, unsigned long jarg11, double jarg12, double jarg13, double jarg14) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  Real arg10 ;
  Size arg11 ;
  Real arg12 ;
  Real arg13 ;
  Real arg14 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (Real)jarg12; 
  arg13 = (Real)jarg13; 
  arg14 = (Real)jarg14; 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9, double jarg10, unsigned long jarg11, double jarg12, double jarg13) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  Real arg10 ;
  Size arg11 ;
  Real arg12 ;
  Real arg13 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (Real)jarg12; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9, double jarg10, unsigned long jarg11, double jarg12) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  Real arg10 ;
  Size arg11 ;
  Real arg12 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (Real)jarg12; 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_6(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9, double jarg10, unsigned long jarg11) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  Real arg10 ;
  Size arg11 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_7(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9, double jarg10) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  Real arg10 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_8(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, unsigned long jarg9) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  Size arg9 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MarkovFunctional__SWIG_9(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Period > *arg7 = 0 ;
  SwapIndexPtr *arg8 = 0 ;
  MarkovFunctionalPtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg8 = (SwapIndexPtr *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SwapIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MarkovFunctionalPtr *)new_MarkovFunctionalPtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< double > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(SwapIndexPtr const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  MarkovFunctionalPtr *arg1 = (MarkovFunctionalPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< bool > *arg7 = 0 ;
  
  arg1 = (MarkovFunctionalPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & type is null", 0);
    return ;
  } 
  {
    try {
      MarkovFunctionalPtr_calibrate__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< double > const &)*arg6,(std::vector< bool > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  MarkovFunctionalPtr *arg1 = (MarkovFunctionalPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  
  arg1 = (MarkovFunctionalPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      MarkovFunctionalPtr_calibrate__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< double > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  MarkovFunctionalPtr *arg1 = (MarkovFunctionalPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (MarkovFunctionalPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  arg5 = (Constraint *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return ;
  } 
  {
    try {
      MarkovFunctionalPtr_calibrate__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_calibrate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  MarkovFunctionalPtr *arg1 = (MarkovFunctionalPtr *) 0 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (MarkovFunctionalPtr *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< CalibrationHelper > > const & type is null", 0);
    return ;
  } 
  arg3 = (OptimizationMethod *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & type is null", 0);
    return ;
  } 
  arg4 = (EndCriteria *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & type is null", 0);
    return ;
  } 
  {
    try {
      MarkovFunctionalPtr_calibrate__SWIG_0(arg1,(std::vector< boost::shared_ptr< CalibrationHelper > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_volatility(void * jarg1) {
  void * jresult ;
  MarkovFunctionalPtr *arg1 = (MarkovFunctionalPtr *) 0 ;
  Array *result = 0 ;
  
  arg1 = (MarkovFunctionalPtr *)jarg1; 
  {
    try {
      result = (Array *) &MarkovFunctionalPtr_volatility((MarkovFunctionalPtr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MarkovFunctional(void * jarg1) {
  MarkovFunctionalPtr *arg1 = (MarkovFunctionalPtr *) 0 ;
  
  arg1 = (MarkovFunctionalPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_0(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Gaussian1dSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dSwaptionEnginePtr *)new_Gaussian1dSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_1(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Gaussian1dSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Gaussian1dSwaptionEnginePtr *)new_Gaussian1dSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_2(void * jarg1, int jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  Gaussian1dSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Gaussian1dSwaptionEnginePtr *)new_Gaussian1dSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_3(void * jarg1, int jarg2, double jarg3) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  Gaussian1dSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Gaussian1dSwaptionEnginePtr *)new_Gaussian1dSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_4(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Gaussian1dSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      result = (Gaussian1dSwaptionEnginePtr *)new_Gaussian1dSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_5(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  Gaussian1dSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dSwaptionEnginePtr *)new_Gaussian1dSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dSwaptionEngine(void * jarg1) {
  Gaussian1dSwaptionEnginePtr *arg1 = (Gaussian1dSwaptionEnginePtr *) 0 ;
  
  arg1 = (Gaussian1dSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dJamshidianSwaptionEngine(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  Gaussian1dJamshidianSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dJamshidianSwaptionEnginePtr *)new_Gaussian1dJamshidianSwaptionEnginePtr((boost::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dJamshidianSwaptionEngine(void * jarg1) {
  Gaussian1dJamshidianSwaptionEnginePtr *arg1 = (Gaussian1dJamshidianSwaptionEnginePtr *) 0 ;
  
  arg1 = (Gaussian1dJamshidianSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_0(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  Gaussian1dNonstandardSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Handle< Quote > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEnginePtr *)new_Gaussian1dNonstandardSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_1(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Gaussian1dNonstandardSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Handle< Quote > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEnginePtr *)new_Gaussian1dNonstandardSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_2(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Gaussian1dNonstandardSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEnginePtr *)new_Gaussian1dNonstandardSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_3(void * jarg1, int jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  Gaussian1dNonstandardSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEnginePtr *)new_Gaussian1dNonstandardSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_4(void * jarg1, int jarg2, double jarg3) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  Gaussian1dNonstandardSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEnginePtr *)new_Gaussian1dNonstandardSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_5(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Gaussian1dNonstandardSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEnginePtr *)new_Gaussian1dNonstandardSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  Gaussian1dNonstandardSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEnginePtr *)new_Gaussian1dNonstandardSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dNonstandardSwaptionEngine(void * jarg1) {
  Gaussian1dNonstandardSwaptionEnginePtr *arg1 = (Gaussian1dNonstandardSwaptionEnginePtr *) 0 ;
  
  arg1 = (Gaussian1dNonstandardSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__Gaussian1dFloatFloatSwaptionEngine(void * jarg1) {
  Gaussian1dFloatFloatSwaptionEngine *arg1 = (Gaussian1dFloatFloatSwaptionEngine *) 0 ;
  
  arg1 = (Gaussian1dFloatFloatSwaptionEngine *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Gaussian1dFloatFloatSwaptionEngine_None_get() {
  int jresult ;
  enum Gaussian1dFloatFloatSwaptionEngine::Probabilities result;
  
  result = (enum Gaussian1dFloatFloatSwaptionEngine::Probabilities)Gaussian1dFloatFloatSwaptionEngine::None;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Gaussian1dFloatFloatSwaptionEngine_Naive_get() {
  int jresult ;
  enum Gaussian1dFloatFloatSwaptionEngine::Probabilities result;
  
  result = (enum Gaussian1dFloatFloatSwaptionEngine::Probabilities)Gaussian1dFloatFloatSwaptionEngine::Naive;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Gaussian1dFloatFloatSwaptionEngine_Digital_get() {
  int jresult ;
  enum Gaussian1dFloatFloatSwaptionEngine::Probabilities result;
  
  result = (enum Gaussian1dFloatFloatSwaptionEngine::Probabilities)Gaussian1dFloatFloatSwaptionEngine::Digital;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_0(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6, void * jarg7, unsigned int jarg8, int jarg9) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  bool arg8 ;
  Gaussian1dFloatFloatSwaptionEngine::Probabilities arg9 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Handle< Quote > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (Gaussian1dFloatFloatSwaptionEngine::Probabilities)jarg9; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_1(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  bool arg8 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Handle< Quote > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_2(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Handle< Quote > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_3(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Handle< Quote > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_4(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_5(void * jarg1, int jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_6(void * jarg1, int jarg2, double jarg3) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  Gaussian1dFloatFloatSwaptionEnginePtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< Gaussian1dModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Gaussian1dModel > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEnginePtr *)new_Gaussian1dFloatFloatSwaptionEnginePtr__SWIG_0((boost::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dFloatFloatSwaptionEngine(void * jarg1) {
  Gaussian1dFloatFloatSwaptionEnginePtr *arg1 = (Gaussian1dFloatFloatSwaptionEnginePtr *) 0 ;
  
  arg1 = (Gaussian1dFloatFloatSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SegmentIntegral(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SegmentIntegral *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (SegmentIntegral *)new SegmentIntegral(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SegmentIntegral(void * jarg1) {
  SegmentIntegral *arg1 = (SegmentIntegral *) 0 ;
  
  arg1 = (SegmentIntegral *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TrapezoidIntegralDefault(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  TrapezoidIntegral< Default > *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TrapezoidIntegral< Default > *)new TrapezoidIntegral< Default >(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TrapezoidIntegralDefault(void * jarg1) {
  TrapezoidIntegral< Default > *arg1 = (TrapezoidIntegral< Default > *) 0 ;
  
  arg1 = (TrapezoidIntegral< Default > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TrapezoidIntegralMidPoint(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  TrapezoidIntegral< MidPoint > *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TrapezoidIntegral< MidPoint > *)new TrapezoidIntegral< MidPoint >(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TrapezoidIntegralMidPoint(void * jarg1) {
  TrapezoidIntegral< MidPoint > *arg1 = (TrapezoidIntegral< MidPoint > *) 0 ;
  
  arg1 = (TrapezoidIntegral< MidPoint > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SimpsonIntegral(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  SimpsonIntegral *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (SimpsonIntegral *)new SimpsonIntegral(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SimpsonIntegral(void * jarg1) {
  SimpsonIntegral *arg1 = (SimpsonIntegral *) 0 ;
  
  arg1 = (SimpsonIntegral *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussKronrodAdaptive__SWIG_0(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  GaussKronrodAdaptive *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (GaussKronrodAdaptive *)new GaussKronrodAdaptive(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussKronrodAdaptive__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  GaussKronrodAdaptive *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (GaussKronrodAdaptive *)new GaussKronrodAdaptive(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussKronrodAdaptive(void * jarg1) {
  GaussKronrodAdaptive *arg1 = (GaussKronrodAdaptive *) 0 ;
  
  arg1 = (GaussKronrodAdaptive *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussKronrodNonAdaptive(double jarg1, unsigned long jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  Real arg3 ;
  GaussKronrodNonAdaptive *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (GaussKronrodNonAdaptive *)new GaussKronrodNonAdaptive(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussKronrodNonAdaptive(void * jarg1) {
  GaussKronrodNonAdaptive *arg1 = (GaussKronrodNonAdaptive *) 0 ;
  
  arg1 = (GaussKronrodNonAdaptive *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussLobattoIntegral__SWIG_0(unsigned long jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  bool arg4 ;
  GaussLobattoIntegral *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (GaussLobattoIntegral *)new GaussLobattoIntegral(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussLobattoIntegral__SWIG_1(unsigned long jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  GaussLobattoIntegral *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (GaussLobattoIntegral *)new GaussLobattoIntegral(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussLobattoIntegral__SWIG_2(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  GaussLobattoIntegral *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (GaussLobattoIntegral *)new GaussLobattoIntegral(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussLobattoIntegral(void * jarg1) {
  GaussLobattoIntegral *arg1 = (GaussLobattoIntegral *) 0 ;
  
  arg1 = (GaussLobattoIntegral *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussLaguerreIntegration__SWIG_0(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  GaussLaguerreIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (GaussLaguerreIntegration *)new GaussLaguerreIntegration(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussLaguerreIntegration__SWIG_1(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GaussLaguerreIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GaussLaguerreIntegration *)new GaussLaguerreIntegration(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussLaguerreIntegration(void * jarg1) {
  GaussLaguerreIntegration *arg1 = (GaussLaguerreIntegration *) 0 ;
  
  arg1 = (GaussLaguerreIntegration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussHermiteIntegration__SWIG_0(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  GaussHermiteIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (GaussHermiteIntegration *)new GaussHermiteIntegration(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussHermiteIntegration__SWIG_1(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GaussHermiteIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GaussHermiteIntegration *)new GaussHermiteIntegration(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussHermiteIntegration(void * jarg1) {
  GaussHermiteIntegration *arg1 = (GaussHermiteIntegration *) 0 ;
  
  arg1 = (GaussHermiteIntegration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussJacobiIntegration(unsigned long jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  GaussJacobiIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (GaussJacobiIntegration *)new GaussJacobiIntegration(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussJacobiIntegration(void * jarg1) {
  GaussJacobiIntegration *arg1 = (GaussJacobiIntegration *) 0 ;
  
  arg1 = (GaussJacobiIntegration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussHyperbolicIntegration(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GaussHyperbolicIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GaussHyperbolicIntegration *)new GaussHyperbolicIntegration(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussHyperbolicIntegration(void * jarg1) {
  GaussHyperbolicIntegration *arg1 = (GaussHyperbolicIntegration *) 0 ;
  
  arg1 = (GaussHyperbolicIntegration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussLegendreIntegration(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GaussLegendreIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GaussLegendreIntegration *)new GaussLegendreIntegration(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussLegendreIntegration(void * jarg1) {
  GaussLegendreIntegration *arg1 = (GaussLegendreIntegration *) 0 ;
  
  arg1 = (GaussLegendreIntegration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussChebyshevIntegration(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GaussChebyshevIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GaussChebyshevIntegration *)new GaussChebyshevIntegration(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussChebyshevIntegration(void * jarg1) {
  GaussChebyshevIntegration *arg1 = (GaussChebyshevIntegration *) 0 ;
  
  arg1 = (GaussChebyshevIntegration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussChebyshev2ndIntegration(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GaussChebyshev2ndIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GaussChebyshev2ndIntegration *)new GaussChebyshev2ndIntegration(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussChebyshev2ndIntegration(void * jarg1) {
  GaussChebyshev2ndIntegration *arg1 = (GaussChebyshev2ndIntegration *) 0 ;
  
  arg1 = (GaussChebyshev2ndIntegration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussGegenbauerIntegration(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  GaussGegenbauerIntegration *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (GaussGegenbauerIntegration *)new GaussGegenbauerIntegration(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussGegenbauerIntegration(void * jarg1) {
  GaussGegenbauerIntegration *arg1 = (GaussGegenbauerIntegration *) 0 ;
  
  arg1 = (GaussGegenbauerIntegration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SampleNumber_value(void * jarg1) {
  double jresult ;
  Sample< Real > *arg1 = (Sample< Real > *) 0 ;
  double result;
  
  arg1 = (Sample< Real > *)jarg1; 
  {
    try {
      result = (double)Sample_Sl_Real_Sg__value(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SampleNumber_weight(void * jarg1) {
  double jresult ;
  Sample< Real > *arg1 = (Sample< Real > *) 0 ;
  Real result;
  
  arg1 = (Sample< Real > *)jarg1; 
  {
    try {
      result = (Real)Sample_Sl_Real_Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SampleNumber(void * jarg1) {
  Sample< Real > *arg1 = (Sample< Real > *) 0 ;
  
  arg1 = (Sample< Real > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SampleArray_value(void * jarg1) {
  void * jresult ;
  Sample< Array > *arg1 = (Sample< Array > *) 0 ;
  Array result;
  
  arg1 = (Sample< Array > *)jarg1; 
  {
    try {
      result = Sample_Sl_Array_Sg__value(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SampleArray_weight(void * jarg1) {
  double jresult ;
  Sample< Array > *arg1 = (Sample< Array > *) 0 ;
  Real result;
  
  arg1 = (Sample< Array > *)jarg1; 
  {
    try {
      result = (Real)Sample_Sl_Array_Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SampleArray(void * jarg1) {
  Sample< Array > *arg1 = (Sample< Array > *) 0 ;
  
  arg1 = (Sample< Array > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SampleRealVector_value(void * jarg1) {
  void * jresult ;
  Sample< std::vector< Real > > *arg1 = (Sample< std::vector< Real > > *) 0 ;
  std::vector< double > result;
  
  arg1 = (Sample< std::vector< Real > > *)jarg1; 
  {
    try {
      result = Sample_Sl_std_vector_Sl_Real_Sg__Sg__value(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< double >((const std::vector< double > &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SampleRealVector_weight(void * jarg1) {
  double jresult ;
  Sample< std::vector< Real > > *arg1 = (Sample< std::vector< Real > > *) 0 ;
  Real result;
  
  arg1 = (Sample< std::vector< Real > > *)jarg1; 
  {
    try {
      result = (Real)Sample_Sl_std_vector_Sl_Real_Sg__Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SampleRealVector(void * jarg1) {
  Sample< std::vector< Real > > *arg1 = (Sample< std::vector< Real > > *) 0 ;
  
  arg1 = (Sample< std::vector< Real > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LecuyerUniformRng__SWIG_0(long jarg1) {
  void * jresult ;
  BigInteger arg1 ;
  LecuyerUniformRng *result = 0 ;
  
  arg1 = (BigInteger)jarg1; 
  {
    try {
      result = (LecuyerUniformRng *)new LecuyerUniformRng(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LecuyerUniformRng__SWIG_1() {
  void * jresult ;
  LecuyerUniformRng *result = 0 ;
  
  {
    try {
      result = (LecuyerUniformRng *)new LecuyerUniformRng();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LecuyerUniformRng_next(void * jarg1) {
  void * jresult ;
  LecuyerUniformRng *arg1 = (LecuyerUniformRng *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (LecuyerUniformRng *)jarg1; 
  {
    try {
      result = ((LecuyerUniformRng const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LecuyerUniformRng(void * jarg1) {
  LecuyerUniformRng *arg1 = (LecuyerUniformRng *) 0 ;
  
  arg1 = (LecuyerUniformRng *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KnuthUniformRng__SWIG_0(long jarg1) {
  void * jresult ;
  BigInteger arg1 ;
  KnuthUniformRng *result = 0 ;
  
  arg1 = (BigInteger)jarg1; 
  {
    try {
      result = (KnuthUniformRng *)new KnuthUniformRng(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KnuthUniformRng__SWIG_1() {
  void * jresult ;
  KnuthUniformRng *result = 0 ;
  
  {
    try {
      result = (KnuthUniformRng *)new KnuthUniformRng();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KnuthUniformRng_next(void * jarg1) {
  void * jresult ;
  KnuthUniformRng *arg1 = (KnuthUniformRng *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (KnuthUniformRng *)jarg1; 
  {
    try {
      result = ((KnuthUniformRng const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KnuthUniformRng(void * jarg1) {
  KnuthUniformRng *arg1 = (KnuthUniformRng *) 0 ;
  
  arg1 = (KnuthUniformRng *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MersenneTwisterUniformRng__SWIG_0(long jarg1) {
  void * jresult ;
  BigInteger arg1 ;
  MersenneTwisterUniformRng *result = 0 ;
  
  arg1 = (BigInteger)jarg1; 
  {
    try {
      result = (MersenneTwisterUniformRng *)new MersenneTwisterUniformRng(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MersenneTwisterUniformRng__SWIG_1() {
  void * jresult ;
  MersenneTwisterUniformRng *result = 0 ;
  
  {
    try {
      result = (MersenneTwisterUniformRng *)new MersenneTwisterUniformRng();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MersenneTwisterUniformRng_next(void * jarg1) {
  void * jresult ;
  MersenneTwisterUniformRng *arg1 = (MersenneTwisterUniformRng *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (MersenneTwisterUniformRng *)jarg1; 
  {
    try {
      result = ((MersenneTwisterUniformRng const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MersenneTwisterUniformRng(void * jarg1) {
  MersenneTwisterUniformRng *arg1 = (MersenneTwisterUniformRng *) 0 ;
  
  arg1 = (MersenneTwisterUniformRng *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UniformRandomGenerator__SWIG_0(long jarg1) {
  void * jresult ;
  BigInteger arg1 ;
  UniformRandomGenerator *result = 0 ;
  
  arg1 = (BigInteger)jarg1; 
  {
    try {
      result = (UniformRandomGenerator *)new UniformRandomGenerator(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UniformRandomGenerator__SWIG_1() {
  void * jresult ;
  UniformRandomGenerator *result = 0 ;
  
  {
    try {
      result = (UniformRandomGenerator *)new UniformRandomGenerator();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_UniformRandomGenerator_next(void * jarg1) {
  void * jresult ;
  UniformRandomGenerator *arg1 = (UniformRandomGenerator *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (UniformRandomGenerator *)jarg1; 
  {
    try {
      result = ((UniformRandomGenerator const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_UniformRandomGenerator_nextValue(void * jarg1) {
  double jresult ;
  UniformRandomGenerator *arg1 = (UniformRandomGenerator *) 0 ;
  Real result;
  
  arg1 = (UniformRandomGenerator *)jarg1; 
  {
    try {
      result = (Real)UniformRandomGenerator_nextValue((UniformRandomGenerator const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UniformRandomGenerator(void * jarg1) {
  UniformRandomGenerator *arg1 = (UniformRandomGenerator *) 0 ;
  
  arg1 = (UniformRandomGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CentralLimitLecuyerGaussianRng(void * jarg1) {
  void * jresult ;
  LecuyerUniformRng *arg1 = 0 ;
  CLGaussianRng< LecuyerUniformRng > *result = 0 ;
  
  arg1 = (LecuyerUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LecuyerUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CLGaussianRng< LecuyerUniformRng > *)new CLGaussianRng< LecuyerUniformRng >((LecuyerUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CentralLimitLecuyerGaussianRng_next(void * jarg1) {
  void * jresult ;
  CLGaussianRng< LecuyerUniformRng > *arg1 = (CLGaussianRng< LecuyerUniformRng > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (CLGaussianRng< LecuyerUniformRng > *)jarg1; 
  {
    try {
      result = ((CLGaussianRng< LecuyerUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CentralLimitLecuyerGaussianRng(void * jarg1) {
  CLGaussianRng< LecuyerUniformRng > *arg1 = (CLGaussianRng< LecuyerUniformRng > *) 0 ;
  
  arg1 = (CLGaussianRng< LecuyerUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CentralLimitKnuthGaussianRng(void * jarg1) {
  void * jresult ;
  KnuthUniformRng *arg1 = 0 ;
  CLGaussianRng< KnuthUniformRng > *result = 0 ;
  
  arg1 = (KnuthUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KnuthUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CLGaussianRng< KnuthUniformRng > *)new CLGaussianRng< KnuthUniformRng >((KnuthUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CentralLimitKnuthGaussianRng_next(void * jarg1) {
  void * jresult ;
  CLGaussianRng< KnuthUniformRng > *arg1 = (CLGaussianRng< KnuthUniformRng > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (CLGaussianRng< KnuthUniformRng > *)jarg1; 
  {
    try {
      result = ((CLGaussianRng< KnuthUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CentralLimitKnuthGaussianRng(void * jarg1) {
  CLGaussianRng< KnuthUniformRng > *arg1 = (CLGaussianRng< KnuthUniformRng > *) 0 ;
  
  arg1 = (CLGaussianRng< KnuthUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CentralLimitMersenneTwisterGaussianRng(void * jarg1) {
  void * jresult ;
  MersenneTwisterUniformRng *arg1 = 0 ;
  CLGaussianRng< MersenneTwisterUniformRng > *result = 0 ;
  
  arg1 = (MersenneTwisterUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MersenneTwisterUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CLGaussianRng< MersenneTwisterUniformRng > *)new CLGaussianRng< MersenneTwisterUniformRng >((MersenneTwisterUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CentralLimitMersenneTwisterGaussianRng_next(void * jarg1) {
  void * jresult ;
  CLGaussianRng< MersenneTwisterUniformRng > *arg1 = (CLGaussianRng< MersenneTwisterUniformRng > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (CLGaussianRng< MersenneTwisterUniformRng > *)jarg1; 
  {
    try {
      result = ((CLGaussianRng< MersenneTwisterUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CentralLimitMersenneTwisterGaussianRng(void * jarg1) {
  CLGaussianRng< MersenneTwisterUniformRng > *arg1 = (CLGaussianRng< MersenneTwisterUniformRng > *) 0 ;
  
  arg1 = (CLGaussianRng< MersenneTwisterUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BoxMullerLecuyerGaussianRng(void * jarg1) {
  void * jresult ;
  LecuyerUniformRng *arg1 = 0 ;
  BoxMullerGaussianRng< LecuyerUniformRng > *result = 0 ;
  
  arg1 = (LecuyerUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LecuyerUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BoxMullerGaussianRng< LecuyerUniformRng > *)new BoxMullerGaussianRng< LecuyerUniformRng >((LecuyerUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BoxMullerLecuyerGaussianRng_next(void * jarg1) {
  void * jresult ;
  BoxMullerGaussianRng< LecuyerUniformRng > *arg1 = (BoxMullerGaussianRng< LecuyerUniformRng > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (BoxMullerGaussianRng< LecuyerUniformRng > *)jarg1; 
  {
    try {
      result = ((BoxMullerGaussianRng< LecuyerUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BoxMullerLecuyerGaussianRng(void * jarg1) {
  BoxMullerGaussianRng< LecuyerUniformRng > *arg1 = (BoxMullerGaussianRng< LecuyerUniformRng > *) 0 ;
  
  arg1 = (BoxMullerGaussianRng< LecuyerUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BoxMullerKnuthGaussianRng(void * jarg1) {
  void * jresult ;
  KnuthUniformRng *arg1 = 0 ;
  BoxMullerGaussianRng< KnuthUniformRng > *result = 0 ;
  
  arg1 = (KnuthUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KnuthUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BoxMullerGaussianRng< KnuthUniformRng > *)new BoxMullerGaussianRng< KnuthUniformRng >((KnuthUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BoxMullerKnuthGaussianRng_next(void * jarg1) {
  void * jresult ;
  BoxMullerGaussianRng< KnuthUniformRng > *arg1 = (BoxMullerGaussianRng< KnuthUniformRng > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (BoxMullerGaussianRng< KnuthUniformRng > *)jarg1; 
  {
    try {
      result = ((BoxMullerGaussianRng< KnuthUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BoxMullerKnuthGaussianRng(void * jarg1) {
  BoxMullerGaussianRng< KnuthUniformRng > *arg1 = (BoxMullerGaussianRng< KnuthUniformRng > *) 0 ;
  
  arg1 = (BoxMullerGaussianRng< KnuthUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BoxMullerMersenneTwisterGaussianRng(void * jarg1) {
  void * jresult ;
  MersenneTwisterUniformRng *arg1 = 0 ;
  BoxMullerGaussianRng< MersenneTwisterUniformRng > *result = 0 ;
  
  arg1 = (MersenneTwisterUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MersenneTwisterUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BoxMullerGaussianRng< MersenneTwisterUniformRng > *)new BoxMullerGaussianRng< MersenneTwisterUniformRng >((MersenneTwisterUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BoxMullerMersenneTwisterGaussianRng_next(void * jarg1) {
  void * jresult ;
  BoxMullerGaussianRng< MersenneTwisterUniformRng > *arg1 = (BoxMullerGaussianRng< MersenneTwisterUniformRng > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (BoxMullerGaussianRng< MersenneTwisterUniformRng > *)jarg1; 
  {
    try {
      result = ((BoxMullerGaussianRng< MersenneTwisterUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BoxMullerMersenneTwisterGaussianRng(void * jarg1) {
  BoxMullerGaussianRng< MersenneTwisterUniformRng > *arg1 = (BoxMullerGaussianRng< MersenneTwisterUniformRng > *) 0 ;
  
  arg1 = (BoxMullerGaussianRng< MersenneTwisterUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInvCumulativeLecuyerGaussianRng(void * jarg1) {
  void * jresult ;
  LecuyerUniformRng *arg1 = 0 ;
  InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (LecuyerUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LecuyerUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *)new InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal >((LecuyerUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeLecuyerGaussianRng_next(void * jarg1) {
  void * jresult ;
  InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeLecuyerGaussianRng(void * jarg1) {
  InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInvCumulativeKnuthGaussianRng(void * jarg1) {
  void * jresult ;
  KnuthUniformRng *arg1 = 0 ;
  InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (KnuthUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KnuthUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *)new InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal >((KnuthUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeKnuthGaussianRng_next(void * jarg1) {
  void * jresult ;
  InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeKnuthGaussianRng(void * jarg1) {
  InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInvCumulativeMersenneTwisterGaussianRng(void * jarg1) {
  void * jresult ;
  MersenneTwisterUniformRng *arg1 = 0 ;
  InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (MersenneTwisterUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MersenneTwisterUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *)new InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal >((MersenneTwisterUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeMersenneTwisterGaussianRng_next(void * jarg1) {
  void * jresult ;
  InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeMersenneTwisterGaussianRng(void * jarg1) {
  InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InvCumulativeLecuyerGaussianRng(void * jarg1) {
  void * jresult ;
  LecuyerUniformRng *arg1 = 0 ;
  InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (LecuyerUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LecuyerUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *)new InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal >((LecuyerUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeLecuyerGaussianRng_next(void * jarg1) {
  void * jresult ;
  InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeLecuyerGaussianRng(void * jarg1) {
  InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InvCumulativeKnuthGaussianRng(void * jarg1) {
  void * jresult ;
  KnuthUniformRng *arg1 = 0 ;
  InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (KnuthUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KnuthUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *)new InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal >((KnuthUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeKnuthGaussianRng_next(void * jarg1) {
  void * jresult ;
  InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeKnuthGaussianRng(void * jarg1) {
  InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InvCumulativeMersenneTwisterGaussianRng(void * jarg1) {
  void * jresult ;
  MersenneTwisterUniformRng *arg1 = 0 ;
  InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (MersenneTwisterUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MersenneTwisterUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *)new InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal >((MersenneTwisterUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeMersenneTwisterGaussianRng_next(void * jarg1) {
  void * jresult ;
  InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeMersenneTwisterGaussianRng(void * jarg1) {
  InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianRandomGenerator(void * jarg1) {
  void * jresult ;
  UniformRandomGenerator *arg1 = 0 ;
  GaussianRandomGenerator *result = 0 ;
  
  arg1 = (UniformRandomGenerator *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "UniformRandomGenerator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GaussianRandomGenerator *)new GaussianRandomGenerator((UniformRandomGenerator const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianRandomGenerator_next(void * jarg1) {
  void * jresult ;
  GaussianRandomGenerator *arg1 = (GaussianRandomGenerator *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (GaussianRandomGenerator *)jarg1; 
  {
    try {
      result = ((GaussianRandomGenerator const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Real >((const Sample< Real > &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GaussianRandomGenerator_nextValue(void * jarg1) {
  double jresult ;
  GaussianRandomGenerator *arg1 = (GaussianRandomGenerator *) 0 ;
  Real result;
  
  arg1 = (GaussianRandomGenerator *)jarg1; 
  {
    try {
      result = (Real)GaussianRandomGenerator_nextValue((GaussianRandomGenerator const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianRandomGenerator(void * jarg1) {
  GaussianRandomGenerator *arg1 = (GaussianRandomGenerator *) 0 ;
  
  arg1 = (GaussianRandomGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HaltonRsg__SWIG_0(unsigned long jarg1, unsigned long jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  Size arg1 ;
  unsigned long arg2 ;
  bool arg3 ;
  bool arg4 ;
  HaltonRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (unsigned long)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (HaltonRsg *)new HaltonRsg(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HaltonRsg__SWIG_1(unsigned long jarg1, unsigned long jarg2, unsigned int jarg3) {
  void * jresult ;
  Size arg1 ;
  unsigned long arg2 ;
  bool arg3 ;
  HaltonRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (unsigned long)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (HaltonRsg *)new HaltonRsg(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HaltonRsg__SWIG_2(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  unsigned long arg2 ;
  HaltonRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (unsigned long)jarg2; 
  {
    try {
      result = (HaltonRsg *)new HaltonRsg(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HaltonRsg__SWIG_3(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  HaltonRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (HaltonRsg *)new HaltonRsg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HaltonRsg_nextSequence(void * jarg1) {
  void * jresult ;
  HaltonRsg *arg1 = (HaltonRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (HaltonRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((HaltonRsg const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HaltonRsg_lastSequence(void * jarg1) {
  void * jresult ;
  HaltonRsg *arg1 = (HaltonRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (HaltonRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((HaltonRsg const *)arg1)->lastSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_HaltonRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  HaltonRsg *arg1 = (HaltonRsg *) 0 ;
  Size result;
  
  arg1 = (HaltonRsg *)jarg1; 
  {
    try {
      result = ((HaltonRsg const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HaltonRsg(void * jarg1) {
  HaltonRsg *arg1 = (HaltonRsg *) 0 ;
  
  arg1 = (HaltonRsg *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolRsg__SWIG_0(unsigned long jarg1, long jarg2, int jarg3) {
  void * jresult ;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  SobolRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigInteger)jarg2; 
  arg3 = (SobolRsg::DirectionIntegers)jarg3; 
  {
    try {
      result = (SobolRsg *)new SobolRsg(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolRsg__SWIG_1(unsigned long jarg1, long jarg2) {
  void * jresult ;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigInteger)jarg2; 
  {
    try {
      result = (SobolRsg *)new SobolRsg(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolRsg__SWIG_2(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SobolRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (SobolRsg *)new SobolRsg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SobolRsg_nextSequence(void * jarg1) {
  void * jresult ;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (SobolRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((SobolRsg const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SobolRsg_lastSequence(void * jarg1) {
  void * jresult ;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (SobolRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((SobolRsg const *)arg1)->lastSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_SobolRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  Size result;
  
  arg1 = (SobolRsg *)jarg1; 
  {
    try {
      result = ((SobolRsg const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SobolRsg_skipTo(void * jarg1, unsigned long jarg2) {
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  Size arg2 ;
  
  arg1 = (SobolRsg *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      (arg1)->skipTo(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SobolRsg_nextInt32Sequence(void * jarg1) {
  void * jresult ;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (SobolRsg *)jarg1; 
  {
    try {
      result = SobolRsg_nextInt32Sequence(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SobolRsg(void * jarg1) {
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  
  arg1 = (SobolRsg *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolBrownianBridgeRsg(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  SobolBrownianBridgeRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (SobolBrownianBridgeRsg *)new SobolBrownianBridgeRsg(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SobolBrownianBridgeRsg_nextSequence(void * jarg1) {
  void * jresult ;
  SobolBrownianBridgeRsg *arg1 = (SobolBrownianBridgeRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (SobolBrownianBridgeRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((SobolBrownianBridgeRsg const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SobolBrownianBridgeRsg_lastSequence(void * jarg1) {
  void * jresult ;
  SobolBrownianBridgeRsg *arg1 = (SobolBrownianBridgeRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (SobolBrownianBridgeRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((SobolBrownianBridgeRsg const *)arg1)->lastSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_SobolBrownianBridgeRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  SobolBrownianBridgeRsg *arg1 = (SobolBrownianBridgeRsg *) 0 ;
  Size result;
  
  arg1 = (SobolBrownianBridgeRsg *)jarg1; 
  {
    try {
      result = ((SobolBrownianBridgeRsg const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SobolBrownianBridgeRsg(void * jarg1) {
  SobolBrownianBridgeRsg *arg1 = (SobolBrownianBridgeRsg *) 0 ;
  
  arg1 = (SobolBrownianBridgeRsg *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LecuyerUniformRsg(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  LecuyerUniformRng *arg2 = 0 ;
  RandomSequenceGenerator< LecuyerUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (LecuyerUniformRng *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LecuyerUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RandomSequenceGenerator< LecuyerUniformRng > *)new RandomSequenceGenerator< LecuyerUniformRng >(arg1,(LecuyerUniformRng const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LecuyerUniformRsg_nextSequence(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((RandomSequenceGenerator< LecuyerUniformRng > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_LecuyerUniformRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *) 0 ;
  Size result;
  
  arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *)jarg1; 
  {
    try {
      result = ((RandomSequenceGenerator< LecuyerUniformRng > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LecuyerUniformRsg(void * jarg1) {
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *) 0 ;
  
  arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KnuthUniformRsg(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  KnuthUniformRng *arg2 = 0 ;
  RandomSequenceGenerator< KnuthUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (KnuthUniformRng *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KnuthUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RandomSequenceGenerator< KnuthUniformRng > *)new RandomSequenceGenerator< KnuthUniformRng >(arg1,(KnuthUniformRng const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KnuthUniformRsg_nextSequence(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = (RandomSequenceGenerator< KnuthUniformRng > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< KnuthUniformRng > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((RandomSequenceGenerator< KnuthUniformRng > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_KnuthUniformRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = (RandomSequenceGenerator< KnuthUniformRng > *) 0 ;
  Size result;
  
  arg1 = (RandomSequenceGenerator< KnuthUniformRng > *)jarg1; 
  {
    try {
      result = ((RandomSequenceGenerator< KnuthUniformRng > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KnuthUniformRsg(void * jarg1) {
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = (RandomSequenceGenerator< KnuthUniformRng > *) 0 ;
  
  arg1 = (RandomSequenceGenerator< KnuthUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MersenneTwisterUniformRsg(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  MersenneTwisterUniformRng *arg2 = 0 ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (MersenneTwisterUniformRng *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MersenneTwisterUniformRng const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)new RandomSequenceGenerator< MersenneTwisterUniformRng >(arg1,(MersenneTwisterUniformRng const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MersenneTwisterUniformRsg_nextSequence(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((RandomSequenceGenerator< MersenneTwisterUniformRng > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MersenneTwisterUniformRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *) 0 ;
  Size result;
  
  arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)jarg1; 
  {
    try {
      result = ((RandomSequenceGenerator< MersenneTwisterUniformRng > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MersenneTwisterUniformRsg(void * jarg1) {
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *) 0 ;
  
  arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UniformRandomSequenceGenerator(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  UniformRandomGenerator *arg2 = 0 ;
  UniformRandomSequenceGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (UniformRandomGenerator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "UniformRandomGenerator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (UniformRandomSequenceGenerator *)new UniformRandomSequenceGenerator(arg1,(UniformRandomGenerator const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_UniformRandomSequenceGenerator_nextSequence(void * jarg1) {
  void * jresult ;
  UniformRandomSequenceGenerator *arg1 = (UniformRandomSequenceGenerator *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (UniformRandomSequenceGenerator *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((UniformRandomSequenceGenerator const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_UniformRandomSequenceGenerator_dimension(void * jarg1) {
  unsigned long jresult ;
  UniformRandomSequenceGenerator *arg1 = (UniformRandomSequenceGenerator *) 0 ;
  Size result;
  
  arg1 = (UniformRandomSequenceGenerator *)jarg1; 
  {
    try {
      result = ((UniformRandomSequenceGenerator const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UniformRandomSequenceGenerator(void * jarg1) {
  UniformRandomSequenceGenerator *arg1 = (UniformRandomSequenceGenerator *) 0 ;
  
  arg1 = (UniformRandomSequenceGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UniformLowDiscrepancySequenceGenerator(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  UniformLowDiscrepancySequenceGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (UniformLowDiscrepancySequenceGenerator *)new UniformLowDiscrepancySequenceGenerator(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_UniformLowDiscrepancySequenceGenerator_nextSequence(void * jarg1) {
  void * jresult ;
  UniformLowDiscrepancySequenceGenerator *arg1 = (UniformLowDiscrepancySequenceGenerator *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (UniformLowDiscrepancySequenceGenerator *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((UniformLowDiscrepancySequenceGenerator const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_UniformLowDiscrepancySequenceGenerator_dimension(void * jarg1) {
  unsigned long jresult ;
  UniformLowDiscrepancySequenceGenerator *arg1 = (UniformLowDiscrepancySequenceGenerator *) 0 ;
  Size result;
  
  arg1 = (UniformLowDiscrepancySequenceGenerator *)jarg1; 
  {
    try {
      result = ((UniformLowDiscrepancySequenceGenerator const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UniformLowDiscrepancySequenceGenerator(void * jarg1) {
  UniformLowDiscrepancySequenceGenerator *arg1 = (UniformLowDiscrepancySequenceGenerator *) 0 ;
  
  arg1 = (UniformLowDiscrepancySequenceGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInvCumulativeLecuyerGaussianRsg(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< LecuyerUniformRng > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< LecuyerUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeLecuyerGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeLecuyerGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeLecuyerGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInvCumulativeKnuthGaussianRsg(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< KnuthUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< KnuthUniformRng > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< KnuthUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeKnuthGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeKnuthGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeKnuthGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInvCumulativeMersenneTwisterGaussianRsg(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< MersenneTwisterUniformRng > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< MersenneTwisterUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeMersenneTwisterGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeMersenneTwisterGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInvCumulativeHaltonGaussianRsg(void * jarg1) {
  void * jresult ;
  HaltonRsg *arg1 = 0 ;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (HaltonRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HaltonRsg const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal >((HaltonRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeHaltonGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeHaltonGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeHaltonGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MoroInvCumulativeSobolGaussianRsg(void * jarg1) {
  void * jresult ;
  SobolRsg *arg1 = 0 ;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (SobolRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SobolRsg const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal >((SobolRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeSobolGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeSobolGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeSobolGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InvCumulativeLecuyerGaussianRsg(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< LecuyerUniformRng > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< LecuyerUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeLecuyerGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InvCumulativeLecuyerGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeLecuyerGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InvCumulativeKnuthGaussianRsg(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< KnuthUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< KnuthUniformRng > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< KnuthUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeKnuthGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InvCumulativeKnuthGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeKnuthGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InvCumulativeMersenneTwisterGaussianRsg(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< MersenneTwisterUniformRng > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< MersenneTwisterUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeMersenneTwisterGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InvCumulativeMersenneTwisterGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeMersenneTwisterGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InvCumulativeHaltonGaussianRsg(void * jarg1) {
  void * jresult ;
  HaltonRsg *arg1 = 0 ;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (HaltonRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HaltonRsg const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal >((HaltonRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeHaltonGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InvCumulativeHaltonGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeHaltonGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InvCumulativeSobolGaussianRsg(void * jarg1) {
  void * jresult ;
  SobolRsg *arg1 = 0 ;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (SobolRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SobolRsg const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal >((SobolRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeSobolGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InvCumulativeSobolGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeSobolGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianRandomSequenceGenerator(void * jarg1) {
  void * jresult ;
  UniformRandomSequenceGenerator *arg1 = 0 ;
  GaussianRandomSequenceGenerator *result = 0 ;
  
  arg1 = (UniformRandomSequenceGenerator *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "UniformRandomSequenceGenerator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GaussianRandomSequenceGenerator *)new GaussianRandomSequenceGenerator((UniformRandomSequenceGenerator const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianRandomSequenceGenerator_nextSequence(void * jarg1) {
  void * jresult ;
  GaussianRandomSequenceGenerator *arg1 = (GaussianRandomSequenceGenerator *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (GaussianRandomSequenceGenerator *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((GaussianRandomSequenceGenerator const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_GaussianRandomSequenceGenerator_dimension(void * jarg1) {
  unsigned long jresult ;
  GaussianRandomSequenceGenerator *arg1 = (GaussianRandomSequenceGenerator *) 0 ;
  Size result;
  
  arg1 = (GaussianRandomSequenceGenerator *)jarg1; 
  {
    try {
      result = ((GaussianRandomSequenceGenerator const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianRandomSequenceGenerator(void * jarg1) {
  GaussianRandomSequenceGenerator *arg1 = (GaussianRandomSequenceGenerator *) 0 ;
  
  arg1 = (GaussianRandomSequenceGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianLowDiscrepancySequenceGenerator(void * jarg1) {
  void * jresult ;
  UniformLowDiscrepancySequenceGenerator *arg1 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *result = 0 ;
  
  arg1 = (UniformLowDiscrepancySequenceGenerator *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "UniformLowDiscrepancySequenceGenerator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GaussianLowDiscrepancySequenceGenerator *)new GaussianLowDiscrepancySequenceGenerator((UniformLowDiscrepancySequenceGenerator const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianLowDiscrepancySequenceGenerator_nextSequence(void * jarg1) {
  void * jresult ;
  GaussianLowDiscrepancySequenceGenerator *arg1 = (GaussianLowDiscrepancySequenceGenerator *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (GaussianLowDiscrepancySequenceGenerator *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((GaussianLowDiscrepancySequenceGenerator const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_GaussianLowDiscrepancySequenceGenerator_dimension(void * jarg1) {
  unsigned long jresult ;
  GaussianLowDiscrepancySequenceGenerator *arg1 = (GaussianLowDiscrepancySequenceGenerator *) 0 ;
  Size result;
  
  arg1 = (GaussianLowDiscrepancySequenceGenerator *)jarg1; 
  {
    try {
      result = ((GaussianLowDiscrepancySequenceGenerator const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianLowDiscrepancySequenceGenerator(void * jarg1) {
  GaussianLowDiscrepancySequenceGenerator *arg1 = (GaussianLowDiscrepancySequenceGenerator *) 0 ;
  
  arg1 = (GaussianLowDiscrepancySequenceGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_getCovariance(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Matrix *arg2 = 0 ;
  Matrix result;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = getCovariance((Array const &)*arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Path_length(void * jarg1) {
  unsigned long jresult ;
  Path *arg1 = (Path *) 0 ;
  Size result;
  
  arg1 = (Path *)jarg1; 
  {
    try {
      result = ((Path const *)arg1)->length();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Path_value(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Path *arg1 = (Path *) 0 ;
  Size arg2 ;
  Real result;
  
  arg1 = (Path *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)((Path const *)arg1)->value(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Path_front(void * jarg1) {
  double jresult ;
  Path *arg1 = (Path *) 0 ;
  Real result;
  
  arg1 = (Path *)jarg1; 
  {
    try {
      result = (Real)((Path const *)arg1)->front();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Path_back(void * jarg1) {
  double jresult ;
  Path *arg1 = (Path *) 0 ;
  Real result;
  
  arg1 = (Path *)jarg1; 
  {
    try {
      result = (Real)((Path const *)arg1)->back();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Path_time(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Path *arg1 = (Path *) 0 ;
  Size arg2 ;
  Time result;
  
  arg1 = (Path *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Time)((Path const *)arg1)->time(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Path(void * jarg1) {
  Path *arg1 = (Path *) 0 ;
  
  arg1 = (Path *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SamplePath_value(void * jarg1) {
  void * jresult ;
  Sample< Path > *arg1 = (Sample< Path > *) 0 ;
  SwigValueWrapper< Path > result;
  
  arg1 = (Sample< Path > *)jarg1; 
  {
    try {
      result = Sample_Sl_Path_Sg__value(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Path((const Path &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SamplePath_weight(void * jarg1) {
  double jresult ;
  Sample< Path > *arg1 = (Sample< Path > *) 0 ;
  Real result;
  
  arg1 = (Sample< Path > *)jarg1; 
  {
    try {
      result = (Real)Sample_Sl_Path_Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SamplePath(void * jarg1) {
  Sample< Path > *arg1 = (Sample< Path > *) 0 ;
  
  arg1 = (Sample< Path > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianPathGenerator(void * jarg1, double jarg2, unsigned long jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  StochasticProcess1DPtr *arg1 = 0 ;
  Time arg2 ;
  Size arg3 ;
  GaussianRandomSequenceGenerator *arg4 = 0 ;
  bool arg5 ;
  GaussianPathGenerator *result = 0 ;
  
  arg1 = (StochasticProcess1DPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcess1DPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Time)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (GaussianRandomSequenceGenerator *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & type is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (GaussianPathGenerator *)new_GaussianPathGenerator((StochasticProcess1DPtr const &)*arg1,arg2,arg3,(GaussianRandomSequenceGenerator const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianPathGenerator_next(void * jarg1) {
  void * jresult ;
  GaussianPathGenerator *arg1 = (GaussianPathGenerator *) 0 ;
  SwigValueWrapper< Sample< Path > > result;
  
  arg1 = (GaussianPathGenerator *)jarg1; 
  {
    try {
      result = ((GaussianPathGenerator const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Path >((const Sample< Path > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianPathGenerator_antithetic(void * jarg1) {
  void * jresult ;
  GaussianPathGenerator *arg1 = (GaussianPathGenerator *) 0 ;
  SwigValueWrapper< Sample< Path > > result;
  
  arg1 = (GaussianPathGenerator *)jarg1; 
  {
    try {
      result = ((GaussianPathGenerator const *)arg1)->antithetic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Path >((const Sample< Path > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianPathGenerator(void * jarg1) {
  GaussianPathGenerator *arg1 = (GaussianPathGenerator *) 0 ;
  
  arg1 = (GaussianPathGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianSobolPathGenerator(void * jarg1, double jarg2, unsigned long jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  StochasticProcess1DPtr *arg1 = 0 ;
  Time arg2 ;
  Size arg3 ;
  GaussianLowDiscrepancySequenceGenerator *arg4 = 0 ;
  bool arg5 ;
  GaussianSobolPathGenerator *result = 0 ;
  
  arg1 = (StochasticProcess1DPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StochasticProcess1DPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (Time)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (GaussianLowDiscrepancySequenceGenerator *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianLowDiscrepancySequenceGenerator const & type is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (GaussianSobolPathGenerator *)new_GaussianSobolPathGenerator((StochasticProcess1DPtr const &)*arg1,arg2,arg3,(GaussianLowDiscrepancySequenceGenerator const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianSobolPathGenerator_next(void * jarg1) {
  void * jresult ;
  GaussianSobolPathGenerator *arg1 = (GaussianSobolPathGenerator *) 0 ;
  SwigValueWrapper< Sample< Path > > result;
  
  arg1 = (GaussianSobolPathGenerator *)jarg1; 
  {
    try {
      result = ((GaussianSobolPathGenerator const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Path >((const Sample< Path > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianSobolPathGenerator_antithetic(void * jarg1) {
  void * jresult ;
  GaussianSobolPathGenerator *arg1 = (GaussianSobolPathGenerator *) 0 ;
  SwigValueWrapper< Sample< Path > > result;
  
  arg1 = (GaussianSobolPathGenerator *)jarg1; 
  {
    try {
      result = ((GaussianSobolPathGenerator const *)arg1)->antithetic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< Path >((const Sample< Path > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianSobolPathGenerator(void * jarg1) {
  GaussianSobolPathGenerator *arg1 = (GaussianSobolPathGenerator *) 0 ;
  
  arg1 = (GaussianSobolPathGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MultiPath_pathSize(void * jarg1) {
  unsigned long jresult ;
  MultiPath *arg1 = (MultiPath *) 0 ;
  Size result;
  
  arg1 = (MultiPath *)jarg1; 
  {
    try {
      result = ((MultiPath const *)arg1)->pathSize();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MultiPath_assetNumber(void * jarg1) {
  unsigned long jresult ;
  MultiPath *arg1 = (MultiPath *) 0 ;
  Size result;
  
  arg1 = (MultiPath *)jarg1; 
  {
    try {
      result = ((MultiPath const *)arg1)->assetNumber();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultiPath_at(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  MultiPath *arg1 = (MultiPath *) 0 ;
  Size arg2 ;
  Path *result = 0 ;
  
  arg1 = (MultiPath *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Path *) &(arg1)->at(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MultiPath(void * jarg1) {
  MultiPath *arg1 = (MultiPath *) 0 ;
  
  arg1 = (MultiPath *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SampleMultiPath_value(void * jarg1) {
  void * jresult ;
  Sample< MultiPath > *arg1 = (Sample< MultiPath > *) 0 ;
  SwigValueWrapper< MultiPath > result;
  
  arg1 = (Sample< MultiPath > *)jarg1; 
  {
    try {
      result = Sample_Sl_MultiPath_Sg__value(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new MultiPath((const MultiPath &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SampleMultiPath_weight(void * jarg1) {
  double jresult ;
  Sample< MultiPath > *arg1 = (Sample< MultiPath > *) 0 ;
  Real result;
  
  arg1 = (Sample< MultiPath > *)jarg1; 
  {
    try {
      result = (Real)Sample_Sl_MultiPath_Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SampleMultiPath(void * jarg1) {
  Sample< MultiPath > *arg1 = (Sample< MultiPath > *) 0 ;
  
  arg1 = (Sample< MultiPath > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianMultiPathGenerator__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  GaussianMultiPathGenerator *result = 0 ;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  arg3 = (GaussianRandomSequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (GaussianMultiPathGenerator *)new_GaussianMultiPathGenerator__SWIG_0((boost::shared_ptr< StochasticProcess > const &)*arg1,(std::vector< double > const &)*arg2,(GaussianRandomSequenceGenerator const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GaussianMultiPathGenerator__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  GaussianMultiPathGenerator *result = 0 ;
  
  arg1 = (boost::shared_ptr< StochasticProcess > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StochasticProcess > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  arg3 = (GaussianRandomSequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (GaussianMultiPathGenerator *)new_GaussianMultiPathGenerator__SWIG_0((boost::shared_ptr< StochasticProcess > const &)*arg1,(std::vector< double > const &)*arg2,(GaussianRandomSequenceGenerator const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianMultiPathGenerator_next(void * jarg1) {
  void * jresult ;
  GaussianMultiPathGenerator *arg1 = (GaussianMultiPathGenerator *) 0 ;
  SwigValueWrapper< Sample< MultiPath > > result;
  
  arg1 = (GaussianMultiPathGenerator *)jarg1; 
  {
    try {
      result = ((GaussianMultiPathGenerator const *)arg1)->next();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< MultiPath >((const Sample< MultiPath > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianMultiPathGenerator_antithetic(void * jarg1) {
  void * jresult ;
  GaussianMultiPathGenerator *arg1 = (GaussianMultiPathGenerator *) 0 ;
  SwigValueWrapper< Sample< MultiPath > > result;
  
  arg1 = (GaussianMultiPathGenerator *)jarg1; 
  {
    try {
      result = ((GaussianMultiPathGenerator const *)arg1)->antithetic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Sample< MultiPath >((const Sample< MultiPath > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianMultiPathGenerator(void * jarg1) {
  GaussianMultiPathGenerator *arg1 = (GaussianMultiPathGenerator *) 0 ;
  
  arg1 = (GaussianMultiPathGenerator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BrownianBridge__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  BrownianBridge *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (BrownianBridge *)new BrownianBridge(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BrownianBridge__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  BrownianBridge *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BrownianBridge *)new BrownianBridge((std::vector< Time > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BrownianBridge__SWIG_2(void * jarg1) {
  void * jresult ;
  TimeGrid *arg1 = 0 ;
  BrownianBridge *result = 0 ;
  
  arg1 = (TimeGrid *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BrownianBridge *)new BrownianBridge((TimeGrid const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_BrownianBridge_size(void * jarg1) {
  unsigned long jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  Size result;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      result = ((BrownianBridge const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianBridge_times(void * jarg1) {
  void * jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< Time > result;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      result = ((BrownianBridge const *)arg1)->times();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Time >((const std::vector< Time > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianBridge_leftWeight(void * jarg1) {
  void * jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< Real > result;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      result = ((BrownianBridge const *)arg1)->leftWeight();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianBridge_rightWeight(void * jarg1) {
  void * jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< Real > result;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      result = ((BrownianBridge const *)arg1)->rightWeight();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianBridge_stdDeviation(void * jarg1) {
  void * jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< Real > result;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      result = ((BrownianBridge const *)arg1)->stdDeviation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianBridge_transform(void * jarg1, void * jarg2) {
  void * jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > result;
  
  arg1 = (BrownianBridge *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = BrownianBridge_transform(arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianBridge_bridgeIndex(void * jarg1) {
  void * jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      result = BrownianBridge_bridgeIndex((BrownianBridge const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianBridge_leftIndex(void * jarg1) {
  void * jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      result = BrownianBridge_leftIndex((BrownianBridge const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianBridge_rightIndex(void * jarg1) {
  void * jresult ;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      result = BrownianBridge_rightIndex((BrownianBridge const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BrownianBridge(void * jarg1) {
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  
  arg1 = (BrownianBridge *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete__BoundaryCondition(void * jarg1) {
  DefaultBoundaryCondition *arg1 = (DefaultBoundaryCondition *) 0 ;
  
  arg1 = (DefaultBoundaryCondition *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BoundaryCondition___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< DefaultBoundaryCondition > *arg1 = (boost::shared_ptr< DefaultBoundaryCondition > *) 0 ;
  DefaultBoundaryCondition *result = 0 ;
  
  arg1 = (boost::shared_ptr< DefaultBoundaryCondition > *)jarg1; 
  {
    try {
      result = (DefaultBoundaryCondition *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BoundaryCondition_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< DefaultBoundaryCondition > *arg1 = (boost::shared_ptr< DefaultBoundaryCondition > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< DefaultBoundaryCondition > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_DefaultBoundaryCondition_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_BoundaryCondition_NoSide_get() {
  int jresult ;
  enum DefaultBoundaryCondition::Side result;
  
  result = (enum DefaultBoundaryCondition::Side)DefaultBoundaryCondition::None;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_BoundaryCondition_Upper_get() {
  int jresult ;
  enum DefaultBoundaryCondition::Side result;
  
  result = (enum DefaultBoundaryCondition::Side)DefaultBoundaryCondition::Upper;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_BoundaryCondition_Lower_get() {
  int jresult ;
  enum DefaultBoundaryCondition::Side result;
  
  result = (enum DefaultBoundaryCondition::Side)DefaultBoundaryCondition::Lower;
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BoundaryCondition() {
  void * jresult ;
  boost::shared_ptr< DefaultBoundaryCondition > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< DefaultBoundaryCondition > *)new boost::shared_ptr< DefaultBoundaryCondition >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BoundaryCondition(void * jarg1) {
  boost::shared_ptr< DefaultBoundaryCondition > *arg1 = (boost::shared_ptr< DefaultBoundaryCondition > *) 0 ;
  
  arg1 = (boost::shared_ptr< DefaultBoundaryCondition > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NeumannBC(double jarg1, int jarg2) {
  void * jresult ;
  Real arg1 ;
  DefaultBoundaryCondition::Side arg2 ;
  NeumannBCPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (DefaultBoundaryCondition::Side)jarg2; 
  {
    try {
      result = (NeumannBCPtr *)new_NeumannBCPtr(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NeumannBC(void * jarg1) {
  NeumannBCPtr *arg1 = (NeumannBCPtr *) 0 ;
  
  arg1 = (NeumannBCPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DirichletBC(double jarg1, int jarg2) {
  void * jresult ;
  Real arg1 ;
  DefaultBoundaryCondition::Side arg2 ;
  DirichletBCPtr *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (DefaultBoundaryCondition::Side)jarg2; 
  {
    try {
      result = (DirichletBCPtr *)new_DirichletBCPtr(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DirichletBC(void * jarg1) {
  DirichletBCPtr *arg1 = (DirichletBCPtr *) 0 ;
  
  arg1 = (DirichletBCPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TridiagonalOperator(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  TridiagonalOperator *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (TridiagonalOperator *)new TridiagonalOperator((Array const &)*arg1,(Array const &)*arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TridiagonalOperator_solveFor(void * jarg1, void * jarg2) {
  void * jresult ;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (TridiagonalOperator *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((TridiagonalOperator const *)arg1)->solveFor((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TridiagonalOperator_applyTo(void * jarg1, void * jarg2) {
  void * jresult ;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (TridiagonalOperator *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((TridiagonalOperator const *)arg1)->applyTo((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Array((const Array &)result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_TridiagonalOperator_size(void * jarg1) {
  unsigned long jresult ;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Size result;
  
  arg1 = (TridiagonalOperator *)jarg1; 
  {
    try {
      result = ((TridiagonalOperator const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_TridiagonalOperator_setFirstRow(void * jarg1, double jarg2, double jarg3) {
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  Real arg3 ;
  
  arg1 = (TridiagonalOperator *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->setFirstRow(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_TridiagonalOperator_setMidRow(void * jarg1, unsigned long jarg2, double jarg3, double jarg4, double jarg5) {
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Size arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  
  arg1 = (TridiagonalOperator *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      (arg1)->setMidRow(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_TridiagonalOperator_setMidRows(void * jarg1, double jarg2, double jarg3, double jarg4) {
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  
  arg1 = (TridiagonalOperator *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      (arg1)->setMidRows(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_TridiagonalOperator_setLastRow(void * jarg1, double jarg2, double jarg3) {
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  Real arg3 ;
  
  arg1 = (TridiagonalOperator *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->setLastRow(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TridiagonalOperator_identity(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = TridiagonalOperator::identity(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TridiagonalOperator((const TridiagonalOperator &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TridiagonalOperator(void * jarg1) {
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  
  arg1 = (TridiagonalOperator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DPlus(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  DPlus *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (DPlus *)new DPlus(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DPlus(void * jarg1) {
  DPlus *arg1 = (DPlus *) 0 ;
  
  arg1 = (DPlus *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DMinus(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  DMinus *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (DMinus *)new DMinus(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DMinus(void * jarg1) {
  DMinus *arg1 = (DMinus *) 0 ;
  
  arg1 = (DMinus *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DZero(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  DZero *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (DZero *)new DZero(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DZero(void * jarg1) {
  DZero *arg1 = (DZero *) 0 ;
  
  arg1 = (DZero *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DPlusDMinus(unsigned long jarg1, double jarg2) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  DPlusDMinus *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (DPlusDMinus *)new DPlusDMinus(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DPlusDMinus(void * jarg1) {
  DPlusDMinus *arg1 = (DPlusDMinus *) 0 ;
  
  arg1 = (DPlusDMinus *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Discount() {
  void * jresult ;
  Discount *result = 0 ;
  
  {
    try {
      result = (Discount *)new Discount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Discount(void * jarg1) {
  Discount *arg1 = (Discount *) 0 ;
  
  arg1 = (Discount *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroYield() {
  void * jresult ;
  ZeroYield *result = 0 ;
  
  {
    try {
      result = (ZeroYield *)new ZeroYield();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroYield(void * jarg1) {
  ZeroYield *arg1 = (ZeroYield *) 0 ;
  
  arg1 = (ZeroYield *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRate() {
  void * jresult ;
  ForwardRate *result = 0 ;
  
  {
    try {
      result = (ForwardRate *)new ForwardRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardRate(void * jarg1) {
  ForwardRate *arg1 = (ForwardRate *) 0 ;
  
  arg1 = (ForwardRate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  BackwardFlat *arg7 = 0 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (BackwardFlat *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6,(BackwardFlat const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  BackwardFlat *arg8 = 0 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (BackwardFlat *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7,(BackwardFlat const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseFlatForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForwardPtr *)new_PiecewiseFlatForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatForward_dates(void * jarg1) {
  void * jresult ;
  PiecewiseFlatForwardPtr *arg1 = (PiecewiseFlatForwardPtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (PiecewiseFlatForwardPtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &PiecewiseFlatForwardPtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatForward_times(void * jarg1) {
  void * jresult ;
  PiecewiseFlatForwardPtr *arg1 = (PiecewiseFlatForwardPtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (PiecewiseFlatForwardPtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &PiecewiseFlatForwardPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatForward_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseFlatForwardPtr *arg1 = (PiecewiseFlatForwardPtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (PiecewiseFlatForwardPtr *)jarg1; 
  {
    try {
      result = PiecewiseFlatForwardPtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseFlatForward(void * jarg1) {
  PiecewiseFlatForwardPtr *arg1 = (PiecewiseFlatForwardPtr *) 0 ;
  
  arg1 = (PiecewiseFlatForwardPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  Linear *arg7 = 0 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6,(Linear const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  Linear *arg8 = 0 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Linear *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7,(Linear const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseLinearForwardPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForwardPtr *)new_PiecewiseLinearForwardPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearForward_dates(void * jarg1) {
  void * jresult ;
  PiecewiseLinearForwardPtr *arg1 = (PiecewiseLinearForwardPtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (PiecewiseLinearForwardPtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &PiecewiseLinearForwardPtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearForward_times(void * jarg1) {
  void * jresult ;
  PiecewiseLinearForwardPtr *arg1 = (PiecewiseLinearForwardPtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (PiecewiseLinearForwardPtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &PiecewiseLinearForwardPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearForward_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseLinearForwardPtr *arg1 = (PiecewiseLinearForwardPtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (PiecewiseLinearForwardPtr *)jarg1; 
  {
    try {
      result = PiecewiseLinearForwardPtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseLinearForward(void * jarg1) {
  PiecewiseLinearForwardPtr *arg1 = (PiecewiseLinearForwardPtr *) 0 ;
  
  arg1 = (PiecewiseLinearForwardPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  Linear *arg7 = 0 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6,(Linear const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  Linear *arg8 = 0 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Linear *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7,(Linear const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseLinearZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZeroPtr *)new_PiecewiseLinearZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearZero_dates(void * jarg1) {
  void * jresult ;
  PiecewiseLinearZeroPtr *arg1 = (PiecewiseLinearZeroPtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (PiecewiseLinearZeroPtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &PiecewiseLinearZeroPtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearZero_times(void * jarg1) {
  void * jresult ;
  PiecewiseLinearZeroPtr *arg1 = (PiecewiseLinearZeroPtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (PiecewiseLinearZeroPtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &PiecewiseLinearZeroPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearZero_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseLinearZeroPtr *arg1 = (PiecewiseLinearZeroPtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (PiecewiseLinearZeroPtr *)jarg1; 
  {
    try {
      result = PiecewiseLinearZeroPtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseLinearZero(void * jarg1) {
  PiecewiseLinearZeroPtr *arg1 = (PiecewiseLinearZeroPtr *) 0 ;
  
  arg1 = (PiecewiseLinearZeroPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  Cubic *arg7 = 0 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Cubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6,(Cubic const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  Cubic *arg8 = 0 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Cubic *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7,(Cubic const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseCubicZeroPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZeroPtr *)new_PiecewiseCubicZeroPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseCubicZero_dates(void * jarg1) {
  void * jresult ;
  PiecewiseCubicZeroPtr *arg1 = (PiecewiseCubicZeroPtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (PiecewiseCubicZeroPtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &PiecewiseCubicZeroPtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseCubicZero_times(void * jarg1) {
  void * jresult ;
  PiecewiseCubicZeroPtr *arg1 = (PiecewiseCubicZeroPtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (PiecewiseCubicZeroPtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &PiecewiseCubicZeroPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseCubicZero_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseCubicZeroPtr *arg1 = (PiecewiseCubicZeroPtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (PiecewiseCubicZeroPtr *)jarg1; 
  {
    try {
      result = PiecewiseCubicZeroPtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseCubicZero(void * jarg1) {
  PiecewiseCubicZeroPtr *arg1 = (PiecewiseCubicZeroPtr *) 0 ;
  
  arg1 = (PiecewiseCubicZeroPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  MonotonicLogCubic *arg7 = 0 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (MonotonicLogCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6,(MonotonicLogCubic const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Real arg6 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_0((Date const &)*arg1,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  MonotonicLogCubic *arg8 = 0 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (MonotonicLogCubic *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7,(MonotonicLogCubic const &)*arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< boost::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseLogCubicDiscountPtr *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< boost::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RateHelper > > const & type is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscountPtr *)new_PiecewiseLogCubicDiscountPtr__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< boost::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogCubicDiscount_dates(void * jarg1) {
  void * jresult ;
  PiecewiseLogCubicDiscountPtr *arg1 = (PiecewiseLogCubicDiscountPtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (PiecewiseLogCubicDiscountPtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &PiecewiseLogCubicDiscountPtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogCubicDiscount_times(void * jarg1) {
  void * jresult ;
  PiecewiseLogCubicDiscountPtr *arg1 = (PiecewiseLogCubicDiscountPtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (PiecewiseLogCubicDiscountPtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &PiecewiseLogCubicDiscountPtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogCubicDiscount_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseLogCubicDiscountPtr *arg1 = (PiecewiseLogCubicDiscountPtr *) 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  arg1 = (PiecewiseLogCubicDiscountPtr *)jarg1; 
  {
    try {
      result = PiecewiseLogCubicDiscountPtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Real > >((const std::vector< std::pair< Date,Real > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseLogCubicDiscount(void * jarg1) {
  PiecewiseLogCubicDiscountPtr *arg1 = (PiecewiseLogCubicDiscountPtr *) 0 ;
  
  arg1 = (PiecewiseLogCubicDiscountPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SampledCurve__SWIG_0() {
  void * jresult ;
  SampledCurve *result = 0 ;
  
  {
    try {
      result = (SampledCurve *)new SampledCurve();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SampledCurve__SWIG_1(void * jarg1) {
  void * jresult ;
  Array *arg1 = 0 ;
  SampledCurve *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SampledCurve *)new SampledCurve((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SampledCurve_grid(void * jarg1) {
  void * jresult ;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *result = 0 ;
  
  arg1 = (SampledCurve *)jarg1; 
  {
    try {
      result = (Array *) &(arg1)->grid();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SampledCurve_values(void * jarg1) {
  void * jresult ;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *result = 0 ;
  
  arg1 = (SampledCurve *)jarg1; 
  {
    try {
      result = (Array *) &(arg1)->values();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SampledCurve_gridValue(void * jarg1, unsigned long jarg2) {
  double jresult ;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Size arg2 ;
  Real result;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)(arg1)->gridValue(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SampledCurve_value(void * jarg1, unsigned long jarg2) {
  double jresult ;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Size arg2 ;
  Real result;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)(arg1)->value(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_SampledCurve_size(void * jarg1) {
  unsigned long jresult ;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Size result;
  
  arg1 = (SampledCurve *)jarg1; 
  {
    try {
      result = ((SampledCurve const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_SampledCurve_empty(void * jarg1) {
  unsigned int jresult ;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  bool result;
  
  arg1 = (SampledCurve *)jarg1; 
  {
    try {
      result = (bool)((SampledCurve const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SampledCurve_setGrid(void * jarg1, void * jarg2) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setGrid((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SampledCurve_setValues(void * jarg1, void * jarg2) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setValues((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SampledCurve_swap(void * jarg1, void * jarg2) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  SampledCurve *arg2 = 0 ;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (SampledCurve *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SampledCurve & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SampledCurve_setLogGrid(void * jarg1, double jarg2, double jarg3) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Real arg2 ;
  Real arg3 ;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->setLogGrid(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SampledCurve_regridLogGrid(void * jarg1, double jarg2, double jarg3) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Real arg2 ;
  Real arg3 ;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->regridLogGrid(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SampledCurve_shiftGrid(void * jarg1, double jarg2) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Real arg2 ;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->shiftGrid(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SampledCurve_scaleGrid(void * jarg1, double jarg2) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Real arg2 ;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->scaleGrid(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SampledCurve_regrid(void * jarg1, void * jarg2) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (SampledCurve *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->regrid((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SampledCurve(void * jarg1) {
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  
  arg1 = (SampledCurve *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Settings_instance() {
  void * jresult ;
  Settings *result = 0 ;
  
  {
    try {
      result = (Settings *) &Settings::instance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Settings_getEvaluationDate(void * jarg1) {
  void * jresult ;
  Settings *arg1 = (Settings *) 0 ;
  Date result;
  
  arg1 = (Settings *)jarg1; 
  {
    try {
      result = Settings_getEvaluationDate(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Date((const Date &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Settings_setEvaluationDate(void * jarg1, void * jarg2) {
  Settings *arg1 = (Settings *) 0 ;
  Date *arg2 = 0 ;
  
  arg1 = (Settings *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return ;
  } 
  {
    try {
      Settings_setEvaluationDate(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Settings_includeReferenceDateEvents(void * jarg1, unsigned int jarg2) {
  Settings *arg1 = (Settings *) 0 ;
  bool arg2 ;
  
  arg1 = (Settings *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      Settings_includeReferenceDateEvents(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Settings_includeTodaysCashFlows(void * jarg1, unsigned int jarg2) {
  Settings *arg1 = (Settings *) 0 ;
  bool arg2 ;
  
  arg1 = (Settings *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      Settings_includeTodaysCashFlows(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Settings(void * jarg1) {
  Settings *arg1 = (Settings *) 0 ;
  
  arg1 = (Settings *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Statistics_samples(void * jarg1) {
  unsigned long jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Size result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = ((Statistics const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_weightSum(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_mean(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_variance(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_standardDeviation(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_errorEstimate(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_skewness(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_kurtosis(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_min(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->min();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Statistics_max(void * jarg1) {
  double jresult ;
  Statistics *arg1 = (Statistics *) 0 ;
  Real result;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      result = (Real)((Statistics const *)arg1)->max();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Statistics_reset(void * jarg1) {
  Statistics *arg1 = (Statistics *) 0 ;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Statistics_add__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  Statistics *arg1 = (Statistics *) 0 ;
  Real arg2 ;
  Real arg3 ;
  
  arg1 = (Statistics *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Statistics_add__SWIG_1(void * jarg1, double jarg2) {
  Statistics *arg1 = (Statistics *) 0 ;
  Real arg2 ;
  
  arg1 = (Statistics *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->add(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Statistics_add__SWIG_2(void * jarg1, void * jarg2) {
  Statistics *arg1 = (Statistics *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  
  arg1 = (Statistics *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      Statistics_add__SWIG_2(arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Statistics_add__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  Statistics *arg1 = (Statistics *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  
  arg1 = (Statistics *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      Statistics_add__SWIG_3(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Statistics() {
  void * jresult ;
  Statistics *result = 0 ;
  
  {
    try {
      result = (Statistics *)new Statistics();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Statistics(void * jarg1) {
  Statistics *arg1 = (Statistics *) 0 ;
  
  arg1 = (Statistics *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_samples(void * jarg1) {
  unsigned long jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Size result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = ((IncrementalStatistics const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_weightSum(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_mean(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_variance(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_standardDeviation(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_errorEstimate(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_skewness(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_kurtosis(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_min(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->min();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_max(void * jarg1) {
  double jresult ;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real result;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->max();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_reset(void * jarg1) {
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_add__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real arg2 ;
  Real arg3 ;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_add__SWIG_1(void * jarg1, double jarg2) {
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real arg2 ;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->add(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_add__SWIG_2(void * jarg1, void * jarg2) {
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      IncrementalStatistics_add__SWIG_2(arg1,(std::vector< double > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IncrementalStatistics_add__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      IncrementalStatistics_add__SWIG_3(arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IncrementalStatistics() {
  void * jresult ;
  IncrementalStatistics *result = 0 ;
  
  {
    try {
      result = (IncrementalStatistics *)new IncrementalStatistics();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IncrementalStatistics(void * jarg1) {
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  
  arg1 = (IncrementalStatistics *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_semiVariance(void * jarg1) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->semiVariance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_semiDeviation(void * jarg1) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->semiDeviation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_downsideVariance(void * jarg1) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->downsideVariance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_downsideDeviation(void * jarg1) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->downsideDeviation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_regret(void * jarg1, double jarg2) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->regret(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_potentialUpside(void * jarg1, double jarg2) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->potentialUpside(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_valueAtRisk(void * jarg1, double jarg2) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->valueAtRisk(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_expectedShortfall(void * jarg1, double jarg2) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->expectedShortfall(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_shortfall(void * jarg1, double jarg2) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->shortfall(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RiskStatistics_averageShortfall(void * jarg1, double jarg2) {
  double jresult ;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (RiskStatistics *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->averageShortfall(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RiskStatistics() {
  void * jresult ;
  RiskStatistics *result = 0 ;
  
  {
    try {
      result = (RiskStatistics *)new RiskStatistics();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RiskStatistics(void * jarg1) {
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  
  arg1 = (RiskStatistics *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MultipleStatistics(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GenericSequenceStatistics< Statistics > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GenericSequenceStatistics< Statistics > *)new GenericSequenceStatistics< Statistics >(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_size(void * jarg1) {
  unsigned long jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Size result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_samples(void * jarg1) {
  unsigned long jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Size result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_weightSum(void * jarg1) {
  double jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Real result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = (Real)((GenericSequenceStatistics< Statistics > const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_mean(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_variance(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_standardDeviation(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_errorEstimate(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_skewness(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_kurtosis(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_min(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->min();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_max(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->max();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_covariance(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Matrix result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->covariance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_correlation(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Matrix result;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->correlation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_reset(void * jarg1) {
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_add__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  Real arg3 ;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add((std::vector< Real > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_add__SWIG_1(void * jarg1, void * jarg2) {
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((std::vector< Real > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_add__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add((Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleStatistics_add__SWIG_3(void * jarg1, void * jarg2) {
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MultipleStatistics(void * jarg1) {
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  
  arg1 = (GenericSequenceStatistics< Statistics > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SequenceStatistics(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GenericSequenceStatistics< RiskStatistics > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GenericSequenceStatistics< RiskStatistics > *)new GenericSequenceStatistics< RiskStatistics >(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_size(void * jarg1) {
  unsigned long jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Size result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_samples(void * jarg1) {
  unsigned long jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Size result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_weightSum(void * jarg1) {
  double jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Real result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = (Real)((GenericSequenceStatistics< RiskStatistics > const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_mean(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_variance(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_standardDeviation(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_errorEstimate(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_skewness(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_kurtosis(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_min(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->min();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_max(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->max();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_covariance(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Matrix result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->covariance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_correlation(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Matrix result;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->correlation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_reset(void * jarg1) {
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_add__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  Real arg3 ;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add((std::vector< Real > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_add__SWIG_1(void * jarg1, void * jarg2) {
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((std::vector< Real > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_add__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add((Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SequenceStatistics_add__SWIG_3(void * jarg1, void * jarg2) {
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SequenceStatistics(void * jarg1) {
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  
  arg1 = (GenericSequenceStatistics< RiskStatistics > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MultipleIncrementalStatistics(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  GenericSequenceStatistics< IncrementalStatistics > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (GenericSequenceStatistics< IncrementalStatistics > *)new GenericSequenceStatistics< IncrementalStatistics >(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_size(void * jarg1) {
  unsigned long jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Size result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_samples(void * jarg1) {
  unsigned long jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Size result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_weightSum(void * jarg1) {
  double jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Real result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = (Real)((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_mean(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_variance(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_standardDeviation(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_errorEstimate(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_skewness(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_kurtosis(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_min(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->min();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_max(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->max();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< Real >((const std::vector< Real > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_covariance(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Matrix result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->covariance();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_correlation(void * jarg1) {
  void * jresult ;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Matrix result;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->correlation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Matrix((const Matrix &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_reset(void * jarg1) {
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_add__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  Real arg3 ;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add((std::vector< Real > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_add__SWIG_1(void * jarg1, void * jarg2) {
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((std::vector< Real > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_add__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add((Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MultipleIncrementalStatistics_add__SWIG_3(void * jarg1, void * jarg2) {
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MultipleIncrementalStatistics(void * jarg1) {
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  
  arg1 = (GenericSequenceStatistics< IncrementalStatistics > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  CapFloorTermVolatilityStructure *result = 0 ;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = (CapFloorTermVolatilityStructure *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_CapFloorTermVolatilityStructure_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_asObservable(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = boost_shared_ptr_Sl_CapFloorTermVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolatilityStructure() {
  void * jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)new boost::shared_ptr< CapFloorTermVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapFloorTermVolatilityStructure(void * jarg1) {
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_volatility__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_volatility__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_volatility__SWIG_2(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_volatility__SWIG_3(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_volatility__SWIG_4(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_volatility__SWIG_5(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  Volatility result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_enableExtrapolation(void * jarg1) {
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_disableExtrapolation(void * jarg1) {
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = 0 ;
  Handle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CapFloorTermVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Handle< CapFloorTermVolatilityStructure > *)new Handle< CapFloorTermVolatilityStructure >((boost::shared_ptr< CapFloorTermVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolatilityStructureHandle__SWIG_1() {
  void * jresult ;
  Handle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (Handle< CapFloorTermVolatilityStructure > *)new Handle< CapFloorTermVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< CapFloorTermVolatilityStructure >((const boost::shared_ptr< CapFloorTermVolatilityStructure > &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(arg1)->empty();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  boost::shared_ptr< Observable > result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = Handle_Sl_CapFloorTermVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new boost::shared_ptr< Observable >((const boost::shared_ptr< Observable > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapFloorTermVolatilityStructureHandle(void * jarg1) {
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_volatility__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_volatility__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Volatility result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_volatility__SWIG_2(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_volatility__SWIG_3(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Volatility result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_volatility__SWIG_4(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  Volatility result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_volatility__SWIG_5(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  Volatility result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_enableExtrapolation(void * jarg1) {
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_disableExtrapolation(void * jarg1) {
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  bool result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableCapFloorTermVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = 0 ;
  RelinkableHandle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  arg1 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CapFloorTermVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (RelinkableHandle< CapFloorTermVolatilityStructure > *)new RelinkableHandle< CapFloorTermVolatilityStructure >((boost::shared_ptr< CapFloorTermVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RelinkableCapFloorTermVolatilityStructureHandle__SWIG_1() {
  void * jresult ;
  RelinkableHandle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  {
    try {
      result = (RelinkableHandle< CapFloorTermVolatilityStructure > *)new RelinkableHandle< CapFloorTermVolatilityStructure >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableCapFloorTermVolatilityStructureHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< CapFloorTermVolatilityStructure > *arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *) 0 ;
  boost::shared_ptr< CapFloorTermVolatilityStructure > *arg2 = 0 ;
  
  arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< CapFloorTermVolatilityStructure > const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->linkTo((boost::shared_ptr< CapFloorTermVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RelinkableCapFloorTermVolatilityStructureHandle(void * jarg1) {
  RelinkableHandle< CapFloorTermVolatilityStructure > *arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolCurve__SWIG_0(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Volatility > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  CapFloorTermVolCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Volatility > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolCurvePtr *)new_CapFloorTermVolCurvePtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolCurve__SWIG_1(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Volatility > *arg5 = 0 ;
  CapFloorTermVolCurvePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Volatility > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolCurvePtr *)new_CapFloorTermVolCurvePtr__SWIG_0((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolCurve__SWIG_2(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Volatility > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  CapFloorTermVolCurvePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Volatility > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & type is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolCurvePtr *)new_CapFloorTermVolCurvePtr__SWIG_2(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolCurve__SWIG_3(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Volatility > *arg5 = 0 ;
  CapFloorTermVolCurvePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Volatility > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolCurvePtr *)new_CapFloorTermVolCurvePtr__SWIG_2(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapFloorTermVolCurve(void * jarg1) {
  CapFloorTermVolCurvePtr *arg1 = (CapFloorTermVolCurvePtr *) 0 ;
  
  arg1 = (CapFloorTermVolCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolSurface__SWIG_0(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  CapFloorTermVolSurfacePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< std::vector< Handle< Quote > > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurfacePtr *)new_CapFloorTermVolSurfacePtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(std::vector< std::vector< Handle< Quote > > > const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolSurface__SWIG_1(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg6 = 0 ;
  CapFloorTermVolSurfacePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< std::vector< Handle< Quote > > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurfacePtr *)new_CapFloorTermVolSurfacePtr__SWIG_0(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(std::vector< std::vector< Handle< Quote > > > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolSurface__SWIG_2(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  CapFloorTermVolSurfacePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< std::vector< Handle< Quote > > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurfacePtr *)new_CapFloorTermVolSurfacePtr__SWIG_2((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(std::vector< std::vector< Handle< Quote > > > const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolSurface__SWIG_3(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg6 = 0 ;
  CapFloorTermVolSurfacePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (std::vector< std::vector< Handle< Quote > > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurfacePtr *)new_CapFloorTermVolSurfacePtr__SWIG_2((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(std::vector< std::vector< Handle< Quote > > > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolSurface__SWIG_4(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  CapFloorTermVolSurfacePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurfacePtr *)new_CapFloorTermVolSurfacePtr__SWIG_4((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolSurface__SWIG_5(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  CapFloorTermVolSurfacePtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurfacePtr *)new_CapFloorTermVolSurfacePtr__SWIG_4((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(Matrix const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolSurface__SWIG_6(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  CapFloorTermVolSurfacePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurfacePtr *)new_CapFloorTermVolSurfacePtr__SWIG_6(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolSurface__SWIG_7(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period > *arg4 = 0 ;
  std::vector< Rate > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  CapFloorTermVolSurfacePtr *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurfacePtr *)new_CapFloorTermVolSurfacePtr__SWIG_6(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< double > const &)*arg5,(Matrix const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapFloorTermVolSurface(void * jarg1) {
  CapFloorTermVolSurfacePtr *arg1 = (CapFloorTermVolSurfacePtr *) 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase___deref__(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  StrippedOptionletBase *result = 0 ;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (StrippedOptionletBase *)(arg1)->operator ->();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_isNull(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  bool result;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (bool)boost_shared_ptr_Sl_StrippedOptionletBase_Sg__isNull(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StrippedOptionletBase() {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *result = 0 ;
  
  {
    try {
      result = (boost::shared_ptr< StrippedOptionletBase > *)new boost::shared_ptr< StrippedOptionletBase >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StrippedOptionletBase(void * jarg1) {
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_optionletStrikes(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  Size arg2 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (std::vector< Rate > *) &(*arg1)->optionletStrikes(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_optionletVolatilities(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  Size arg2 ;
  std::vector< Volatility > *result = 0 ;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (std::vector< Volatility > *) &(*arg1)->optionletVolatilities(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_optionletFixingDates(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &(*arg1)->optionletFixingDates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_optionletFixingTimes(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &(*arg1)->optionletFixingTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_optionletMaturities(void * jarg1) {
  unsigned long jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  Size result;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (*arg1)->optionletMaturities();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_atmOptionletRates(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &(*arg1)->atmOptionletRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_dayCounter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new DayCounter((const DayCounter &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_calendar(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Calendar((const Calendar &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_settlementDays(void * jarg1) {
  unsigned int jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  Natural result;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (Natural)(*arg1)->settlementDays();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_businessDayConvention(void * jarg1) {
  int jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = (boost::shared_ptr< StrippedOptionletBase > *) 0 ;
  BusinessDayConvention result;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1; 
  {
    try {
      result = (BusinessDayConvention)(*arg1)->businessDayConvention();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned int jarg5, void * jarg6, int jarg7, double jarg8, unsigned int jarg9) {
  void * jresult ;
  CapFloorTermVolSurfacePtr *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  bool arg9 ;
  OptionletStripper1Ptr *result = 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CapFloorTermVolSurfacePtr const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (OptionletStripper1Ptr *)new_OptionletStripper1Ptr__SWIG_0((CapFloorTermVolSurfacePtr const &)*arg1,(IborIndexPtr const &)*arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned int jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  CapFloorTermVolSurfacePtr *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  OptionletStripper1Ptr *result = 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CapFloorTermVolSurfacePtr const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (OptionletStripper1Ptr *)new_OptionletStripper1Ptr__SWIG_0((CapFloorTermVolSurfacePtr const &)*arg1,(IborIndexPtr const &)*arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_2(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned int jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  CapFloorTermVolSurfacePtr *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  VolatilityType arg7 ;
  OptionletStripper1Ptr *result = 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CapFloorTermVolSurfacePtr const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (OptionletStripper1Ptr *)new_OptionletStripper1Ptr__SWIG_0((CapFloorTermVolSurfacePtr const &)*arg1,(IborIndexPtr const &)*arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_3(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  CapFloorTermVolSurfacePtr *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  OptionletStripper1Ptr *result = 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CapFloorTermVolSurfacePtr const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (OptionletStripper1Ptr *)new_OptionletStripper1Ptr__SWIG_0((CapFloorTermVolSurfacePtr const &)*arg1,(IborIndexPtr const &)*arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_4(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  void * jresult ;
  CapFloorTermVolSurfacePtr *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  OptionletStripper1Ptr *result = 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CapFloorTermVolSurfacePtr const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  {
    try {
      result = (OptionletStripper1Ptr *)new_OptionletStripper1Ptr__SWIG_0((CapFloorTermVolSurfacePtr const &)*arg1,(IborIndexPtr const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_5(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  void * jresult ;
  CapFloorTermVolSurfacePtr *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  OptionletStripper1Ptr *result = 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CapFloorTermVolSurfacePtr const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (OptionletStripper1Ptr *)new_OptionletStripper1Ptr__SWIG_0((CapFloorTermVolSurfacePtr const &)*arg1,(IborIndexPtr const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_6(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  CapFloorTermVolSurfacePtr *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  Rate arg3 ;
  OptionletStripper1Ptr *result = 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CapFloorTermVolSurfacePtr const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (OptionletStripper1Ptr *)new_OptionletStripper1Ptr__SWIG_0((CapFloorTermVolSurfacePtr const &)*arg1,(IborIndexPtr const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_7(void * jarg1, void * jarg2) {
  void * jresult ;
  CapFloorTermVolSurfacePtr *arg1 = 0 ;
  IborIndexPtr *arg2 = 0 ;
  OptionletStripper1Ptr *result = 0 ;
  
  arg1 = (CapFloorTermVolSurfacePtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CapFloorTermVolSurfacePtr const & type is null", 0);
    return 0;
  } 
  arg2 = (IborIndexPtr *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "IborIndexPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (OptionletStripper1Ptr *)new_OptionletStripper1Ptr__SWIG_0((CapFloorTermVolSurfacePtr const &)*arg1,(IborIndexPtr const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletStripper1_capFloorPrices(void * jarg1) {
  void * jresult ;
  OptionletStripper1Ptr *arg1 = (OptionletStripper1Ptr *) 0 ;
  Matrix *result = 0 ;
  
  arg1 = (OptionletStripper1Ptr *)jarg1; 
  {
    try {
      result = (Matrix *) &OptionletStripper1Ptr_capFloorPrices((OptionletStripper1Ptr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletStripper1_capFloorVolatilities(void * jarg1) {
  void * jresult ;
  OptionletStripper1Ptr *arg1 = (OptionletStripper1Ptr *) 0 ;
  Matrix *result = 0 ;
  
  arg1 = (OptionletStripper1Ptr *)jarg1; 
  {
    try {
      result = (Matrix *) &OptionletStripper1Ptr_capFloorVolatilities((OptionletStripper1Ptr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletStripper1_optionletPrices(void * jarg1) {
  void * jresult ;
  OptionletStripper1Ptr *arg1 = (OptionletStripper1Ptr *) 0 ;
  Matrix *result = 0 ;
  
  arg1 = (OptionletStripper1Ptr *)jarg1; 
  {
    try {
      result = (Matrix *) &OptionletStripper1Ptr_optionletPrices((OptionletStripper1Ptr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletStripper1_switchStrike(void * jarg1) {
  double jresult ;
  OptionletStripper1Ptr *arg1 = (OptionletStripper1Ptr *) 0 ;
  Rate result;
  
  arg1 = (OptionletStripper1Ptr *)jarg1; 
  {
    try {
      result = (Rate)OptionletStripper1Ptr_switchStrike((OptionletStripper1Ptr const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OptionletStripper1(void * jarg1) {
  OptionletStripper1Ptr *arg1 = (OptionletStripper1Ptr *) 0 ;
  
  arg1 = (OptionletStripper1Ptr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StrippedOptionletAdapter(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< StrippedOptionletBase > *arg1 = 0 ;
  StrippedOptionletAdapterPtr *result = 0 ;
  
  arg1 = (boost::shared_ptr< StrippedOptionletBase > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< StrippedOptionletBase > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (StrippedOptionletAdapterPtr *)new_StrippedOptionletAdapterPtr((boost::shared_ptr< StrippedOptionletBase > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StrippedOptionletAdapter(void * jarg1) {
  StrippedOptionletAdapterPtr *arg1 = (StrippedOptionletAdapterPtr *) 0 ;
  
  arg1 = (StrippedOptionletAdapterPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Settlement() {
  void * jresult ;
  Settlement *result = 0 ;
  
  {
    try {
      result = (Settlement *)new Settlement();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Settlement(void * jarg1) {
  Settlement *arg1 = (Settlement *) 0 ;
  
  arg1 = (Settlement *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Swaption__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  VanillaSwapPtr *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  SwaptionPtr *result = 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "VanillaSwapPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg3 = (Settlement::Type)jarg3; 
  {
    try {
      result = (SwaptionPtr *)new_SwaptionPtr__SWIG_0((VanillaSwapPtr const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Swaption__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  VanillaSwapPtr *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  SwaptionPtr *result = 0 ;
  
  arg1 = (VanillaSwapPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "VanillaSwapPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionPtr *)new_SwaptionPtr__SWIG_0((VanillaSwapPtr const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Swaption(void * jarg1) {
  SwaptionPtr *arg1 = (SwaptionPtr *) 0 ;
  
  arg1 = (SwaptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonstandardSwaption__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  NonstandardSwaptionPtr *result = 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NonstandardSwapPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  arg3 = (Settlement::Type)jarg3; 
  {
    try {
      result = (NonstandardSwaptionPtr *)new_NonstandardSwaptionPtr__SWIG_0((NonstandardSwapPtr const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonstandardSwaption__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  NonstandardSwapPtr *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  NonstandardSwaptionPtr *result = 0 ;
  
  arg1 = (NonstandardSwapPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NonstandardSwapPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (NonstandardSwaptionPtr *)new_NonstandardSwaptionPtr__SWIG_0((NonstandardSwapPtr const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwaption_calibrationBasket(void * jarg1, void * jarg2, void * jarg3, char * jarg4) {
  void * jresult ;
  NonstandardSwaptionPtr *arg1 = (NonstandardSwaptionPtr *) 0 ;
  boost::shared_ptr< Index > arg2 ;
  boost::shared_ptr< SwaptionVolatilityStructure > arg3 ;
  std::string arg4 ;
  boost::shared_ptr< Index > *argp2 ;
  boost::shared_ptr< SwaptionVolatilityStructure > *argp3 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > result;
  
  arg1 = (NonstandardSwaptionPtr *)jarg1; 
  argp2 = (boost::shared_ptr< Index > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Index >", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< SwaptionVolatilityStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg4)->assign(jarg4); 
  {
    try {
      result = NonstandardSwaptionPtr_calibrationBasket(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< boost::shared_ptr< CalibrationHelper > >((const std::vector< boost::shared_ptr< CalibrationHelper > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NonstandardSwaption(void * jarg1) {
  NonstandardSwaptionPtr *arg1 = (NonstandardSwaptionPtr *) 0 ;
  
  arg1 = (NonstandardSwaptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwaption(void * jarg1, void * jarg2) {
  void * jresult ;
  FloatFloatSwapPtr *arg1 = 0 ;
  boost::shared_ptr< Exercise > *arg2 = 0 ;
  FloatFloatSwaptionPtr *result = 0 ;
  
  arg1 = (FloatFloatSwapPtr *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FloatFloatSwapPtr const & type is null", 0);
    return 0;
  } 
  arg2 = (boost::shared_ptr< Exercise > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< Exercise > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwaptionPtr *)new_FloatFloatSwaptionPtr((FloatFloatSwapPtr const &)*arg1,(boost::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FloatFloatSwaption_calibrationBasket(void * jarg1, void * jarg2, void * jarg3, char * jarg4) {
  void * jresult ;
  FloatFloatSwaptionPtr *arg1 = (FloatFloatSwaptionPtr *) 0 ;
  boost::shared_ptr< Index > arg2 ;
  boost::shared_ptr< SwaptionVolatilityStructure > arg3 ;
  std::string arg4 ;
  boost::shared_ptr< Index > *argp2 ;
  boost::shared_ptr< SwaptionVolatilityStructure > *argp3 ;
  std::vector< boost::shared_ptr< CalibrationHelper > > result;
  
  arg1 = (FloatFloatSwaptionPtr *)jarg1; 
  argp2 = (boost::shared_ptr< Index > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< Index >", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::shared_ptr< SwaptionVolatilityStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg4)->assign(jarg4); 
  {
    try {
      result = FloatFloatSwaptionPtr_calibrationBasket(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< boost::shared_ptr< CalibrationHelper > >((const std::vector< boost::shared_ptr< CalibrationHelper > > &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatFloatSwaption_underlyingValue(void * jarg1) {
  double jresult ;
  FloatFloatSwaptionPtr *arg1 = (FloatFloatSwaptionPtr *) 0 ;
  Real result;
  
  arg1 = (FloatFloatSwaptionPtr *)jarg1; 
  {
    try {
      result = (Real)FloatFloatSwaptionPtr_underlyingValue(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloatFloatSwaption(void * jarg1) {
  FloatFloatSwaptionPtr *arg1 = (FloatFloatSwaptionPtr *) 0 ;
  
  arg1 = (FloatFloatSwaptionPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackSwaptionEngine__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  BlackSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (BlackSwaptionEnginePtr *)new_BlackSwaptionEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackSwaptionEngine__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  BlackSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackSwaptionEnginePtr *)new_BlackSwaptionEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackSwaptionEngine__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  BlackSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackSwaptionEnginePtr *)new_BlackSwaptionEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackSwaptionEngine__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  BlackSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< SwaptionVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackSwaptionEnginePtr *)new_BlackSwaptionEnginePtr__SWIG_3((Handle< YieldTermStructure > const &)*arg1,(Handle< SwaptionVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackSwaptionEngine_vega(void * jarg1) {
  double jresult ;
  BlackSwaptionEnginePtr *arg1 = (BlackSwaptionEnginePtr *) 0 ;
  Real result;
  
  arg1 = (BlackSwaptionEnginePtr *)jarg1; 
  {
    try {
      result = (Real)BlackSwaptionEnginePtr_vega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackSwaptionEngine(void * jarg1) {
  BlackSwaptionEnginePtr *arg1 = (BlackSwaptionEnginePtr *) 0 ;
  
  arg1 = (BlackSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BachelierSwaptionEngine__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  BachelierSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierSwaptionEnginePtr *)new_BachelierSwaptionEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BachelierSwaptionEngine__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  BachelierSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierSwaptionEnginePtr *)new_BachelierSwaptionEnginePtr__SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BachelierSwaptionEngine__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  BachelierSwaptionEnginePtr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg2 = (Handle< SwaptionVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierSwaptionEnginePtr *)new_BachelierSwaptionEnginePtr__SWIG_2((Handle< YieldTermStructure > const &)*arg1,(Handle< SwaptionVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BachelierSwaptionEngine(void * jarg1) {
  BachelierSwaptionEnginePtr *arg1 = (BachelierSwaptionEnginePtr *) 0 ;
  
  arg1 = (BachelierSwaptionEnginePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_enableTracing() {
  {
    try {
      enableTracing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_disableTracing() {
  {
    try {
      disableTracing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantEstimator(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  ConstantEstimator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (ConstantEstimator *)new ConstantEstimator(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ConstantEstimator_calculate(void * jarg1, void * jarg2) {
  void * jresult ;
  ConstantEstimator *arg1 = (ConstantEstimator *) 0 ;
  TimeSeries< Volatility > *arg2 = 0 ;
  TimeSeries< Volatility > result;
  
  arg1 = (ConstantEstimator *)jarg1; 
  arg2 = (TimeSeries< Volatility > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeSeries< Volatility > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->calculate((TimeSeries< Volatility > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< Volatility >((const TimeSeries< Volatility > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConstantEstimator(void * jarg1) {
  ConstantEstimator *arg1 = (ConstantEstimator *) 0 ;
  
  arg1 = (ConstantEstimator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ParkinsonSigma(double jarg1) {
  void * jresult ;
  Real arg1 ;
  ParkinsonSigma *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (ParkinsonSigma *)new ParkinsonSigma(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ParkinsonSigma_calculate(void * jarg1, void * jarg2) {
  void * jresult ;
  ParkinsonSigma *arg1 = (ParkinsonSigma *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  TimeSeries< Volatility > result;
  
  arg1 = (ParkinsonSigma *)jarg1; 
  arg2 = (TimeSeries< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeSeries< IntervalPrice > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< Volatility >((const TimeSeries< Volatility > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ParkinsonSigma(void * jarg1) {
  ParkinsonSigma *arg1 = (ParkinsonSigma *) 0 ;
  
  arg1 = (ParkinsonSigma *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GarmanKlassSigma1(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  GarmanKlassSigma1 *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (GarmanKlassSigma1 *)new GarmanKlassSigma1(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GarmanKlassSigma1_calculate(void * jarg1, void * jarg2) {
  void * jresult ;
  GarmanKlassSigma1 *arg1 = (GarmanKlassSigma1 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  TimeSeries< Volatility > result;
  
  arg1 = (GarmanKlassSigma1 *)jarg1; 
  arg2 = (TimeSeries< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeSeries< IntervalPrice > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< Volatility >((const TimeSeries< Volatility > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GarmanKlassSigma1(void * jarg1) {
  GarmanKlassSigma1 *arg1 = (GarmanKlassSigma1 *) 0 ;
  
  arg1 = (GarmanKlassSigma1 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GarmanKlassSigma3(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  GarmanKlassSigma3 *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (GarmanKlassSigma3 *)new GarmanKlassSigma3(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GarmanKlassSigma3_calculate(void * jarg1, void * jarg2) {
  void * jresult ;
  GarmanKlassSigma3 *arg1 = (GarmanKlassSigma3 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  TimeSeries< Volatility > result;
  
  arg1 = (GarmanKlassSigma3 *)jarg1; 
  arg2 = (TimeSeries< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeSeries< IntervalPrice > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< Volatility >((const TimeSeries< Volatility > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GarmanKlassSigma3(void * jarg1) {
  GarmanKlassSigma3 *arg1 = (GarmanKlassSigma3 *) 0 ;
  
  arg1 = (GarmanKlassSigma3 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GarmanKlassSigma4(double jarg1) {
  void * jresult ;
  Real arg1 ;
  GarmanKlassSigma4 *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (GarmanKlassSigma4 *)new GarmanKlassSigma4(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GarmanKlassSigma4_calculate(void * jarg1, void * jarg2) {
  void * jresult ;
  GarmanKlassSigma4 *arg1 = (GarmanKlassSigma4 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  TimeSeries< Volatility > result;
  
  arg1 = (GarmanKlassSigma4 *)jarg1; 
  arg2 = (TimeSeries< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeSeries< IntervalPrice > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< Volatility >((const TimeSeries< Volatility > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GarmanKlassSigma4(void * jarg1) {
  GarmanKlassSigma4 *arg1 = (GarmanKlassSigma4 *) 0 ;
  
  arg1 = (GarmanKlassSigma4 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GarmanKlassSigma5(double jarg1) {
  void * jresult ;
  Real arg1 ;
  GarmanKlassSigma5 *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (GarmanKlassSigma5 *)new GarmanKlassSigma5(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GarmanKlassSigma5_calculate(void * jarg1, void * jarg2) {
  void * jresult ;
  GarmanKlassSigma5 *arg1 = (GarmanKlassSigma5 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  TimeSeries< Volatility > result;
  
  arg1 = (GarmanKlassSigma5 *)jarg1; 
  arg2 = (TimeSeries< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeSeries< IntervalPrice > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< Volatility >((const TimeSeries< Volatility > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GarmanKlassSigma5(void * jarg1) {
  GarmanKlassSigma5 *arg1 = (GarmanKlassSigma5 *) 0 ;
  
  arg1 = (GarmanKlassSigma5 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GarmanKlassSigma6(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  GarmanKlassSigma6 *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (GarmanKlassSigma6 *)new GarmanKlassSigma6(arg1,arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GarmanKlassSigma6_calculate(void * jarg1, void * jarg2) {
  void * jresult ;
  GarmanKlassSigma6 *arg1 = (GarmanKlassSigma6 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  TimeSeries< Volatility > result;
  
  arg1 = (GarmanKlassSigma6 *)jarg1; 
  arg2 = (TimeSeries< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeSeries< IntervalPrice > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeSeries< Volatility >((const TimeSeries< Volatility > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GarmanKlassSigma6(void * jarg1) {
  GarmanKlassSigma6 *arg1 = (GarmanKlassSigma6 *) 0 ;
  
  arg1 = (GarmanKlassSigma6 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  ZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (ZeroCurvePtr *)new_ZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  Compounding arg6 ;
  ZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (ZeroCurvePtr *)new_ZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  ZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCurvePtr *)new_ZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCurve__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  ZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCurvePtr *)new_ZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  ZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCurvePtr *)new_ZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_times(void * jarg1) {
  void * jresult ;
  ZeroCurvePtr *arg1 = (ZeroCurvePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (ZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &ZeroCurvePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_data(void * jarg1) {
  void * jresult ;
  ZeroCurvePtr *arg1 = (ZeroCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (ZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &ZeroCurvePtr_data(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_dates(void * jarg1) {
  void * jresult ;
  ZeroCurvePtr *arg1 = (ZeroCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (ZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &ZeroCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  ZeroCurvePtr *arg1 = (ZeroCurvePtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (ZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &ZeroCurvePtr_zeroRates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  ZeroCurvePtr *arg1 = (ZeroCurvePtr *) 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  arg1 = (ZeroCurvePtr *)jarg1; 
  {
    try {
      result = ZeroCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Rate > >((const std::vector< std::pair< Date,Rate > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroCurve(void * jarg1) {
  ZeroCurvePtr *arg1 = (ZeroCurvePtr *) 0 ;
  
  arg1 = (ZeroCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogLinearZeroCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  LogLinearZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (LogLinearZeroCurvePtr *)new_LogLinearZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogLinear const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogLinearZeroCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  Compounding arg6 ;
  LogLinearZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (LogLinearZeroCurvePtr *)new_LogLinearZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogLinear const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogLinearZeroCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  LogLinearZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogLinearZeroCurvePtr *)new_LogLinearZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogLinear const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogLinearZeroCurve__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinearZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogLinearZeroCurvePtr *)new_LogLinearZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogLinearZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  LogLinearZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogLinearZeroCurvePtr *)new_LogLinearZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_times(void * jarg1) {
  void * jresult ;
  LogLinearZeroCurvePtr *arg1 = (LogLinearZeroCurvePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (LogLinearZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &LogLinearZeroCurvePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_data(void * jarg1) {
  void * jresult ;
  LogLinearZeroCurvePtr *arg1 = (LogLinearZeroCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (LogLinearZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &LogLinearZeroCurvePtr_data(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_dates(void * jarg1) {
  void * jresult ;
  LogLinearZeroCurvePtr *arg1 = (LogLinearZeroCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (LogLinearZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &LogLinearZeroCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  LogLinearZeroCurvePtr *arg1 = (LogLinearZeroCurvePtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (LogLinearZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &LogLinearZeroCurvePtr_zeroRates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  LogLinearZeroCurvePtr *arg1 = (LogLinearZeroCurvePtr *) 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  arg1 = (LogLinearZeroCurvePtr *)jarg1; 
  {
    try {
      result = LogLinearZeroCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Rate > >((const std::vector< std::pair< Date,Rate > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogLinearZeroCurve(void * jarg1) {
  LogLinearZeroCurvePtr *arg1 = (LogLinearZeroCurvePtr *) 0 ;
  
  arg1 = (LogLinearZeroCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicZeroCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  CubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (CubicZeroCurvePtr *)new_CubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Cubic const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicZeroCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  Compounding arg6 ;
  CubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (CubicZeroCurvePtr *)new_CubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Cubic const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicZeroCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  CubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CubicZeroCurvePtr *)new_CubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Cubic const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicZeroCurve__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  CubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CubicZeroCurvePtr *)new_CubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  CubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (CubicZeroCurvePtr *)new_CubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_times(void * jarg1) {
  void * jresult ;
  CubicZeroCurvePtr *arg1 = (CubicZeroCurvePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (CubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &CubicZeroCurvePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_data(void * jarg1) {
  void * jresult ;
  CubicZeroCurvePtr *arg1 = (CubicZeroCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (CubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &CubicZeroCurvePtr_data(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_dates(void * jarg1) {
  void * jresult ;
  CubicZeroCurvePtr *arg1 = (CubicZeroCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (CubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &CubicZeroCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  CubicZeroCurvePtr *arg1 = (CubicZeroCurvePtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (CubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &CubicZeroCurvePtr_zeroRates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  CubicZeroCurvePtr *arg1 = (CubicZeroCurvePtr *) 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  arg1 = (CubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = CubicZeroCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Rate > >((const std::vector< std::pair< Date,Rate > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CubicZeroCurve(void * jarg1) {
  CubicZeroCurvePtr *arg1 = (CubicZeroCurvePtr *) 0 ;
  
  arg1 = (CubicZeroCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogCubicZeroCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DefaultLogCubic *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  LogCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (DefaultLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DefaultLogCubic const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (LogCubicZeroCurvePtr *)new_LogCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(DefaultLogCubic const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogCubicZeroCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DefaultLogCubic *arg5 = 0 ;
  Compounding arg6 ;
  LogCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (DefaultLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DefaultLogCubic const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (LogCubicZeroCurvePtr *)new_LogCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(DefaultLogCubic const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogCubicZeroCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DefaultLogCubic *arg5 = 0 ;
  LogCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (DefaultLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DefaultLogCubic const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogCubicZeroCurvePtr *)new_LogCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(DefaultLogCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogCubicZeroCurve__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogCubicZeroCurvePtr *)new_LogCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogCubicZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  LogCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogCubicZeroCurvePtr *)new_LogCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_times(void * jarg1) {
  void * jresult ;
  LogCubicZeroCurvePtr *arg1 = (LogCubicZeroCurvePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (LogCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &LogCubicZeroCurvePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_data(void * jarg1) {
  void * jresult ;
  LogCubicZeroCurvePtr *arg1 = (LogCubicZeroCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (LogCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &LogCubicZeroCurvePtr_data(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_dates(void * jarg1) {
  void * jresult ;
  LogCubicZeroCurvePtr *arg1 = (LogCubicZeroCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (LogCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &LogCubicZeroCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  LogCubicZeroCurvePtr *arg1 = (LogCubicZeroCurvePtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (LogCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &LogCubicZeroCurvePtr_zeroRates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  LogCubicZeroCurvePtr *arg1 = (LogCubicZeroCurvePtr *) 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  arg1 = (LogCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = LogCubicZeroCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Rate > >((const std::vector< std::pair< Date,Rate > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogCubicZeroCurve(void * jarg1) {
  LogCubicZeroCurvePtr *arg1 = (LogCubicZeroCurvePtr *) 0 ;
  
  arg1 = (LogCubicZeroCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardFlatZeroCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  ForwardFlat *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  ForwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (ForwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ForwardFlat const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (ForwardFlatZeroCurvePtr *)new_ForwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(ForwardFlat const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardFlatZeroCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  ForwardFlat *arg5 = 0 ;
  Compounding arg6 ;
  ForwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (ForwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ForwardFlat const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (ForwardFlatZeroCurvePtr *)new_ForwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(ForwardFlat const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardFlatZeroCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  ForwardFlat *arg5 = 0 ;
  ForwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (ForwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ForwardFlat const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardFlatZeroCurvePtr *)new_ForwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(ForwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardFlatZeroCurve__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  ForwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardFlatZeroCurvePtr *)new_ForwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardFlatZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  ForwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardFlatZeroCurvePtr *)new_ForwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardFlatZeroCurve_times(void * jarg1) {
  void * jresult ;
  ForwardFlatZeroCurvePtr *arg1 = (ForwardFlatZeroCurvePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (ForwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &ForwardFlatZeroCurvePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardFlatZeroCurve_data(void * jarg1) {
  void * jresult ;
  ForwardFlatZeroCurvePtr *arg1 = (ForwardFlatZeroCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (ForwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &ForwardFlatZeroCurvePtr_data(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardFlatZeroCurve_dates(void * jarg1) {
  void * jresult ;
  ForwardFlatZeroCurvePtr *arg1 = (ForwardFlatZeroCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (ForwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &ForwardFlatZeroCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardFlatZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  ForwardFlatZeroCurvePtr *arg1 = (ForwardFlatZeroCurvePtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (ForwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &ForwardFlatZeroCurvePtr_zeroRates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardFlatZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  ForwardFlatZeroCurvePtr *arg1 = (ForwardFlatZeroCurvePtr *) 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  arg1 = (ForwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = ForwardFlatZeroCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Rate > >((const std::vector< std::pair< Date,Rate > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardFlatZeroCurve(void * jarg1) {
  ForwardFlatZeroCurvePtr *arg1 = (ForwardFlatZeroCurvePtr *) 0 ;
  
  arg1 = (ForwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BackwardFlatZeroCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  BackwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (BackwardFlatZeroCurvePtr *)new_BackwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(BackwardFlat const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BackwardFlatZeroCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  Compounding arg6 ;
  BackwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (BackwardFlatZeroCurvePtr *)new_BackwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(BackwardFlat const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BackwardFlatZeroCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  BackwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BackwardFlatZeroCurvePtr *)new_BackwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(BackwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BackwardFlatZeroCurve__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BackwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BackwardFlatZeroCurvePtr *)new_BackwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BackwardFlatZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  BackwardFlatZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (BackwardFlatZeroCurvePtr *)new_BackwardFlatZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BackwardFlatZeroCurve_times(void * jarg1) {
  void * jresult ;
  BackwardFlatZeroCurvePtr *arg1 = (BackwardFlatZeroCurvePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (BackwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &BackwardFlatZeroCurvePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BackwardFlatZeroCurve_data(void * jarg1) {
  void * jresult ;
  BackwardFlatZeroCurvePtr *arg1 = (BackwardFlatZeroCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (BackwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &BackwardFlatZeroCurvePtr_data(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BackwardFlatZeroCurve_dates(void * jarg1) {
  void * jresult ;
  BackwardFlatZeroCurvePtr *arg1 = (BackwardFlatZeroCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (BackwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &BackwardFlatZeroCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BackwardFlatZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  BackwardFlatZeroCurvePtr *arg1 = (BackwardFlatZeroCurvePtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (BackwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &BackwardFlatZeroCurvePtr_zeroRates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BackwardFlatZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  BackwardFlatZeroCurvePtr *arg1 = (BackwardFlatZeroCurvePtr *) 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  arg1 = (BackwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      result = BackwardFlatZeroCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Rate > >((const std::vector< std::pair< Date,Rate > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BackwardFlatZeroCurve(void * jarg1) {
  BackwardFlatZeroCurvePtr *arg1 = (BackwardFlatZeroCurvePtr *) 0 ;
  
  arg1 = (BackwardFlatZeroCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicZeroCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  MonotonicCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (MonotonicCubicZeroCurvePtr *)new_MonotonicCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(MonotonicCubic const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicZeroCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  Compounding arg6 ;
  MonotonicCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & type is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (MonotonicCubicZeroCurvePtr *)new_MonotonicCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(MonotonicCubic const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicZeroCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  MonotonicCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MonotonicCubicZeroCurvePtr *)new_MonotonicCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(MonotonicCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicZeroCurve__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  MonotonicCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MonotonicCubicZeroCurvePtr *)new_MonotonicCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  MonotonicCubicZeroCurvePtr *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & type is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (MonotonicCubicZeroCurvePtr *)new_MonotonicCubicZeroCurvePtr__SWIG_0((std::vector< Date > const &)*arg1,(std::vector< double > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_times(void * jarg1) {
  void * jresult ;
  MonotonicCubicZeroCurvePtr *arg1 = (MonotonicCubicZeroCurvePtr *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (MonotonicCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &MonotonicCubicZeroCurvePtr_times(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_data(void * jarg1) {
  void * jresult ;
  MonotonicCubicZeroCurvePtr *arg1 = (MonotonicCubicZeroCurvePtr *) 0 ;
  std::vector< Real > *result = 0 ;
  
  arg1 = (MonotonicCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Real > *) &MonotonicCubicZeroCurvePtr_data(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_dates(void * jarg1) {
  void * jresult ;
  MonotonicCubicZeroCurvePtr *arg1 = (MonotonicCubicZeroCurvePtr *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (MonotonicCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &MonotonicCubicZeroCurvePtr_dates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  MonotonicCubicZeroCurvePtr *arg1 = (MonotonicCubicZeroCurvePtr *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (MonotonicCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &MonotonicCubicZeroCurvePtr_zeroRates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  MonotonicCubicZeroCurvePtr *arg1 = (MonotonicCubicZeroCurvePtr *) 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  arg1 = (MonotonicCubicZeroCurvePtr *)jarg1; 
  {
    try {
      result = MonotonicCubicZeroCurvePtr_nodes(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new std::vector< std::pair< Date,Rate > >((const std::vector< std::pair< Date,Rate > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicCubicZeroCurve(void * jarg1) {
  MonotonicCubicZeroCurvePtr *arg1 = (MonotonicCubicZeroCurvePtr *) 0 ;
  
  arg1 = (MonotonicCubicZeroCurvePtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_zerocurve(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  SwigValueWrapper< ZeroCurvePtr > result;
  
  arg1 = (boost::shared_ptr< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::shared_ptr< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = as_zerocurve((boost::shared_ptr< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new ZeroCurvePtr((const ZeroCurvePtr &)result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Forward_forwardValue(void * jarg1) {
  double jresult ;
  ForwardPtr *arg1 = (ForwardPtr *) 0 ;
  Real result;
  
  arg1 = (ForwardPtr *)jarg1; 
  {
    try {
      result = (Real)ForwardPtr_forwardValue(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Forward_impliedYield(void * jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  ForwardPtr *arg1 = (ForwardPtr *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Date arg4 ;
  Compounding arg5 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Date *argp4 ;
  DayCounter *argp6 ;
  InterestRate result;
  
  arg1 = (ForwardPtr *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  argp4 = (Date *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (Compounding)jarg5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = ForwardPtr_impliedYield(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new InterestRate((const InterestRate &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Forward() {
  void * jresult ;
  ForwardPtr *result = 0 ;
  
  {
    try {
      result = (ForwardPtr *)new ForwardPtr();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Forward(void * jarg1) {
  ForwardPtr *arg1 = (ForwardPtr *) 0 ;
  
  arg1 = (ForwardPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondForward__SWIG_0(void * jarg1, void * jarg2, int jarg3, double jarg4, unsigned int jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  FixedRateBondPtr *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  FixedRateBondForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (FixedRateBondPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FixedRateBondPtr const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondForwardPtr *)new_FixedRateBondForwardPtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(FixedRateBondPtr const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,(Handle< YieldTermStructure > const &)*arg11);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondForward__SWIG_1(void * jarg1, void * jarg2, int jarg3, double jarg4, unsigned int jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  FixedRateBondPtr *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  FixedRateBondForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (FixedRateBondPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FixedRateBondPtr const & type is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondForwardPtr *)new_FixedRateBondForwardPtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(FixedRateBondPtr const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedRateBondForward__SWIG_2(void * jarg1, void * jarg2, int jarg3, double jarg4, unsigned int jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  FixedRateBondPtr *arg9 = 0 ;
  FixedRateBondForwardPtr *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & type is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & type is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (FixedRateBondPtr *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FixedRateBondPtr const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondForwardPtr *)new_FixedRateBondForwardPtr__SWIG_0((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(FixedRateBondPtr const &)*arg9);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FixedRateBondForward_forwardPrice(void * jarg1) {
  double jresult ;
  FixedRateBondForwardPtr *arg1 = (FixedRateBondForwardPtr *) 0 ;
  Real result;
  
  arg1 = (FixedRateBondForwardPtr *)jarg1; 
  {
    try {
      result = (Real)FixedRateBondForwardPtr_forwardPrice(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FixedRateBondForward_cleanForwardPrice(void * jarg1) {
  double jresult ;
  FixedRateBondForwardPtr *arg1 = (FixedRateBondForwardPtr *) 0 ;
  Real result;
  
  arg1 = (FixedRateBondForwardPtr *)jarg1; 
  {
    try {
      result = (Real)FixedRateBondForwardPtr_cleanForwardPrice(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FixedRateBondForward_spotIncome(void * jarg1, void * jarg2) {
  double jresult ;
  FixedRateBondForwardPtr *arg1 = (FixedRateBondForwardPtr *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Real result;
  
  arg1 = (FixedRateBondForwardPtr *)jarg1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)FixedRateBondForwardPtr_spotIncome(arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FixedRateBondForward_spotValue(void * jarg1) {
  double jresult ;
  FixedRateBondForwardPtr *arg1 = (FixedRateBondForwardPtr *) 0 ;
  Real result;
  
  arg1 = (FixedRateBondForwardPtr *)jarg1; 
  {
    try {
      result = (Real)FixedRateBondForwardPtr_spotValue(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedRateBondForward(void * jarg1) {
  FixedRateBondForwardPtr *arg1 = (FixedRateBondForwardPtr *) 0 ;
  
  arg1 = (FixedRateBondForwardPtr *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT boost::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_EuropeanExercise_SWIGUpcast(EuropeanExercisePtr *jarg1) {
    return (boost::shared_ptr< Exercise > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_AmericanExercise_SWIGUpcast(AmericanExercisePtr *jarg1) {
    return (boost::shared_ptr< Exercise > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_BermudanExercise_SWIGUpcast(BermudanExercisePtr *jarg1) {
    return (boost::shared_ptr< Exercise > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_RebatedExercise_SWIGUpcast(RebatedExercisePtr *jarg1) {
    return (boost::shared_ptr< Exercise > *)jarg1;
}

SWIGEXPORT Handle< Quote > * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandle_SWIGUpcast(RelinkableHandle< Quote > *jarg1) {
    return (Handle< Quote > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Quote > * SWIGSTDCALL CSharp_QuantLib_SimpleQuote_SWIGUpcast(SimpleQuotePtr *jarg1) {
    return (boost::shared_ptr< Quote > *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Argentina_SWIGUpcast(QuantLib::Argentina *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Australia_SWIGUpcast(QuantLib::Australia *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Brazil_SWIGUpcast(QuantLib::Brazil *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Canada_SWIGUpcast(QuantLib::Canada *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_China_SWIGUpcast(QuantLib::China *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_CzechRepublic_SWIGUpcast(QuantLib::CzechRepublic *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Denmark_SWIGUpcast(QuantLib::Denmark *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Finland_SWIGUpcast(QuantLib::Finland *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Germany_SWIGUpcast(QuantLib::Germany *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_HongKong_SWIGUpcast(QuantLib::HongKong *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Hungary_SWIGUpcast(QuantLib::Hungary *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Iceland_SWIGUpcast(QuantLib::Iceland *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_India_SWIGUpcast(QuantLib::India *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Indonesia_SWIGUpcast(QuantLib::Indonesia *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Israel_SWIGUpcast(QuantLib::Israel *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Italy_SWIGUpcast(QuantLib::Italy *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Japan_SWIGUpcast(QuantLib::Japan *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Mexico_SWIGUpcast(QuantLib::Mexico *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_NewZealand_SWIGUpcast(QuantLib::NewZealand *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Norway_SWIGUpcast(QuantLib::Norway *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Poland_SWIGUpcast(QuantLib::Poland *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Russia_SWIGUpcast(QuantLib::Russia *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Romania_SWIGUpcast(QuantLib::Romania *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_SaudiArabia_SWIGUpcast(QuantLib::SaudiArabia *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Singapore_SWIGUpcast(QuantLib::Singapore *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Slovakia_SWIGUpcast(QuantLib::Slovakia *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_SouthAfrica_SWIGUpcast(QuantLib::SouthAfrica *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_SouthKorea_SWIGUpcast(QuantLib::SouthKorea *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Sweden_SWIGUpcast(QuantLib::Sweden *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Switzerland_SWIGUpcast(QuantLib::Switzerland *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Taiwan_SWIGUpcast(QuantLib::Taiwan *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_TARGET_SWIGUpcast(QuantLib::TARGET *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Turkey_SWIGUpcast(QuantLib::Turkey *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Ukraine_SWIGUpcast(QuantLib::Ukraine *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_UnitedKingdom_SWIGUpcast(QuantLib::UnitedKingdom *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_UnitedStates_SWIGUpcast(QuantLib::UnitedStates *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_NullCalendar_SWIGUpcast(QuantLib::NullCalendar *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_WeekendsOnly_SWIGUpcast(QuantLib::WeekendsOnly *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_JointCalendar_SWIGUpcast(QuantLib::JointCalendar *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_BespokeCalendar_SWIGUpcast(QuantLib::BespokeCalendar *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_Actual360_SWIGUpcast(QuantLib::Actual360 *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_Actual365Fixed_SWIGUpcast(QuantLib::Actual365Fixed *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_Thirty360_SWIGUpcast(QuantLib::Thirty360 *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_ActualActual_SWIGUpcast(QuantLib::ActualActual *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_OneDayCounter_SWIGUpcast(QuantLib::OneDayCounter *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_SimpleDayCounter_SWIGUpcast(QuantLib::SimpleDayCounter *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_Business252_SWIGUpcast(QuantLib::Business252 *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT Rounding * SWIGSTDCALL CSharp_QuantLib_UpRounding_SWIGUpcast(UpRounding *jarg1) {
    return (Rounding *)jarg1;
}

SWIGEXPORT Rounding * SWIGSTDCALL CSharp_QuantLib_DownRounding_SWIGUpcast(DownRounding *jarg1) {
    return (Rounding *)jarg1;
}

SWIGEXPORT Rounding * SWIGSTDCALL CSharp_QuantLib_ClosestRounding_SWIGUpcast(ClosestRounding *jarg1) {
    return (Rounding *)jarg1;
}

SWIGEXPORT Rounding * SWIGSTDCALL CSharp_QuantLib_CeilingTruncation_SWIGUpcast(CeilingTruncation *jarg1) {
    return (Rounding *)jarg1;
}

SWIGEXPORT Rounding * SWIGSTDCALL CSharp_QuantLib_FloorTruncation_SWIGUpcast(FloorTruncation *jarg1) {
    return (Rounding *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ARSCurrency_SWIGUpcast(QuantLib::ARSCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ATSCurrency_SWIGUpcast(QuantLib::ATSCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_AUDCurrency_SWIGUpcast(QuantLib::AUDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BDTCurrency_SWIGUpcast(QuantLib::BDTCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BEFCurrency_SWIGUpcast(QuantLib::BEFCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BGLCurrency_SWIGUpcast(QuantLib::BGLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BRLCurrency_SWIGUpcast(QuantLib::BRLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BYRCurrency_SWIGUpcast(QuantLib::BYRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_CADCurrency_SWIGUpcast(QuantLib::CADCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_CHFCurrency_SWIGUpcast(QuantLib::CHFCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_CLPCurrency_SWIGUpcast(QuantLib::CLPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_CNYCurrency_SWIGUpcast(QuantLib::CNYCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_COPCurrency_SWIGUpcast(QuantLib::COPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_CYPCurrency_SWIGUpcast(QuantLib::CYPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_CZKCurrency_SWIGUpcast(QuantLib::CZKCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_DEMCurrency_SWIGUpcast(QuantLib::DEMCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_DKKCurrency_SWIGUpcast(QuantLib::DKKCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_EEKCurrency_SWIGUpcast(QuantLib::EEKCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ESPCurrency_SWIGUpcast(QuantLib::ESPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_EURCurrency_SWIGUpcast(QuantLib::EURCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_FIMCurrency_SWIGUpcast(QuantLib::FIMCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_FRFCurrency_SWIGUpcast(QuantLib::FRFCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_GBPCurrency_SWIGUpcast(QuantLib::GBPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_GRDCurrency_SWIGUpcast(QuantLib::GRDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_HKDCurrency_SWIGUpcast(QuantLib::HKDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_HUFCurrency_SWIGUpcast(QuantLib::HUFCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_IEPCurrency_SWIGUpcast(QuantLib::IEPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_IDRCurrency_SWIGUpcast(QuantLib::IDRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ILSCurrency_SWIGUpcast(QuantLib::ILSCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_INRCurrency_SWIGUpcast(QuantLib::INRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_IQDCurrency_SWIGUpcast(QuantLib::IQDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_IRRCurrency_SWIGUpcast(QuantLib::IRRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ISKCurrency_SWIGUpcast(QuantLib::ISKCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ITLCurrency_SWIGUpcast(QuantLib::ITLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_JPYCurrency_SWIGUpcast(QuantLib::JPYCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_KRWCurrency_SWIGUpcast(QuantLib::KRWCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_KWDCurrency_SWIGUpcast(QuantLib::KWDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_LTLCurrency_SWIGUpcast(QuantLib::LTLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_LUFCurrency_SWIGUpcast(QuantLib::LUFCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_LVLCurrency_SWIGUpcast(QuantLib::LVLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_MTLCurrency_SWIGUpcast(QuantLib::MTLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_MXNCurrency_SWIGUpcast(QuantLib::MXNCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_MYRCurrency_SWIGUpcast(QuantLib::MYRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_NLGCurrency_SWIGUpcast(QuantLib::NLGCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_NOKCurrency_SWIGUpcast(QuantLib::NOKCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_NPRCurrency_SWIGUpcast(QuantLib::NPRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_NZDCurrency_SWIGUpcast(QuantLib::NZDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_PEHCurrency_SWIGUpcast(QuantLib::PEHCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_PEICurrency_SWIGUpcast(QuantLib::PEICurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_PENCurrency_SWIGUpcast(QuantLib::PENCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_PKRCurrency_SWIGUpcast(QuantLib::PKRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_PLNCurrency_SWIGUpcast(QuantLib::PLNCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_PTECurrency_SWIGUpcast(QuantLib::PTECurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ROLCurrency_SWIGUpcast(QuantLib::ROLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_RONCurrency_SWIGUpcast(QuantLib::RONCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_RUBCurrency_SWIGUpcast(QuantLib::RUBCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_SARCurrency_SWIGUpcast(QuantLib::SARCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_SEKCurrency_SWIGUpcast(QuantLib::SEKCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_SGDCurrency_SWIGUpcast(QuantLib::SGDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_SITCurrency_SWIGUpcast(QuantLib::SITCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_SKKCurrency_SWIGUpcast(QuantLib::SKKCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_THBCurrency_SWIGUpcast(QuantLib::THBCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_TRLCurrency_SWIGUpcast(QuantLib::TRLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_TRYCurrency_SWIGUpcast(QuantLib::TRYCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_TTDCurrency_SWIGUpcast(QuantLib::TTDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_TWDCurrency_SWIGUpcast(QuantLib::TWDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_USDCurrency_SWIGUpcast(QuantLib::USDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_VEBCurrency_SWIGUpcast(QuantLib::VEBCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_VNDCurrency_SWIGUpcast(QuantLib::VNDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ZARCurrency_SWIGUpcast(QuantLib::ZARCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Handle< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableYieldTermStructureHandle_SWIGUpcast(RelinkableHandle< YieldTermStructure > *jarg1) {
    return (Handle< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ImpliedTermStructure_SWIGUpcast(ImpliedTermStructurePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ZeroSpreadedTermStructure_SWIGUpcast(ZeroSpreadedTermStructurePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ForwardSpreadedTermStructure_SWIGUpcast(ForwardSpreadedTermStructurePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_SpreadedLinearZeroInterpolatedTermStructure_SWIGUpcast(SpreadedLinearZeroInterpolatedTermStructurePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_FlatForward_SWIGUpcast(FlatForwardPtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Index > * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_SWIGUpcast(InterestRateIndexPtr *jarg1) {
    return (boost::shared_ptr< Index > *)jarg1;
}

SWIGEXPORT InterestRateIndexPtr * SWIGSTDCALL CSharp_QuantLib_IborIndex_SWIGUpcast(IborIndexPtr *jarg1) {
    return (InterestRateIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_OvernightIndex_SWIGUpcast(OvernightIndexPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Libor_SWIGUpcast(LiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT InterestRateIndexPtr * SWIGSTDCALL CSharp_QuantLib_SwapIndex_SWIGUpcast(SwapIndexPtr *jarg1) {
    return (InterestRateIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_AUDLibor_SWIGUpcast(AUDLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_CADLibor_SWIGUpcast(CADLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Cdor_SWIGUpcast(CdorPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_CHFLibor_SWIGUpcast(CHFLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_DKKLibor_SWIGUpcast(DKKLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Bbsw_SWIGUpcast(BbswPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT BbswPtr * SWIGSTDCALL CSharp_QuantLib_Bbsw1M_SWIGUpcast(Bbsw1MPtr *jarg1) {
    return (BbswPtr *)jarg1;
}

SWIGEXPORT BbswPtr * SWIGSTDCALL CSharp_QuantLib_Bbsw2M_SWIGUpcast(Bbsw2MPtr *jarg1) {
    return (BbswPtr *)jarg1;
}

SWIGEXPORT BbswPtr * SWIGSTDCALL CSharp_QuantLib_Bbsw3M_SWIGUpcast(Bbsw3MPtr *jarg1) {
    return (BbswPtr *)jarg1;
}

SWIGEXPORT BbswPtr * SWIGSTDCALL CSharp_QuantLib_Bbsw4M_SWIGUpcast(Bbsw4MPtr *jarg1) {
    return (BbswPtr *)jarg1;
}

SWIGEXPORT BbswPtr * SWIGSTDCALL CSharp_QuantLib_Bbsw5M_SWIGUpcast(Bbsw5MPtr *jarg1) {
    return (BbswPtr *)jarg1;
}

SWIGEXPORT BbswPtr * SWIGSTDCALL CSharp_QuantLib_Bbsw6M_SWIGUpcast(Bbsw6MPtr *jarg1) {
    return (BbswPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Bkbm_SWIGUpcast(BkbmPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT BkbmPtr * SWIGSTDCALL CSharp_QuantLib_Bkbm1M_SWIGUpcast(Bkbm1MPtr *jarg1) {
    return (BkbmPtr *)jarg1;
}

SWIGEXPORT BkbmPtr * SWIGSTDCALL CSharp_QuantLib_Bkbm2M_SWIGUpcast(Bkbm2MPtr *jarg1) {
    return (BkbmPtr *)jarg1;
}

SWIGEXPORT BkbmPtr * SWIGSTDCALL CSharp_QuantLib_Bkbm3M_SWIGUpcast(Bkbm3MPtr *jarg1) {
    return (BkbmPtr *)jarg1;
}

SWIGEXPORT BkbmPtr * SWIGSTDCALL CSharp_QuantLib_Bkbm4M_SWIGUpcast(Bkbm4MPtr *jarg1) {
    return (BkbmPtr *)jarg1;
}

SWIGEXPORT BkbmPtr * SWIGSTDCALL CSharp_QuantLib_Bkbm5M_SWIGUpcast(Bkbm5MPtr *jarg1) {
    return (BkbmPtr *)jarg1;
}

SWIGEXPORT BkbmPtr * SWIGSTDCALL CSharp_QuantLib_Bkbm6M_SWIGUpcast(Bkbm6MPtr *jarg1) {
    return (BkbmPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Euribor_SWIGUpcast(EuriborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_EuriborSW_SWIGUpcast(EuriborSWPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor2W_SWIGUpcast(Euribor2WPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor3W_SWIGUpcast(Euribor3WPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor1M_SWIGUpcast(Euribor1MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor2M_SWIGUpcast(Euribor2MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor3M_SWIGUpcast(Euribor3MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor4M_SWIGUpcast(Euribor4MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor5M_SWIGUpcast(Euribor5MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor6M_SWIGUpcast(Euribor6MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor7M_SWIGUpcast(Euribor7MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor8M_SWIGUpcast(Euribor8MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor9M_SWIGUpcast(Euribor9MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor10M_SWIGUpcast(Euribor10MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor11M_SWIGUpcast(Euribor11MPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT EuriborPtr * SWIGSTDCALL CSharp_QuantLib_Euribor1Y_SWIGUpcast(Euribor1YPtr *jarg1) {
    return (EuriborPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Euribor365_SWIGUpcast(Euribor365Ptr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_SW_SWIGUpcast(Euribor365_SWPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_2W_SWIGUpcast(Euribor365_2WPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_3W_SWIGUpcast(Euribor365_3WPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_1M_SWIGUpcast(Euribor365_1MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_2M_SWIGUpcast(Euribor365_2MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_3M_SWIGUpcast(Euribor365_3MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_4M_SWIGUpcast(Euribor365_4MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_5M_SWIGUpcast(Euribor365_5MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_6M_SWIGUpcast(Euribor365_6MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_7M_SWIGUpcast(Euribor365_7MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_8M_SWIGUpcast(Euribor365_8MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_9M_SWIGUpcast(Euribor365_9MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_10M_SWIGUpcast(Euribor365_10MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_11M_SWIGUpcast(Euribor365_11MPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT Euribor365Ptr * SWIGSTDCALL CSharp_QuantLib_Euribor365_1Y_SWIGUpcast(Euribor365_1YPtr *jarg1) {
    return (Euribor365Ptr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor_SWIGUpcast(EURLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLiborSW_SWIGUpcast(EURLiborSWPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor2W_SWIGUpcast(EURLibor2WPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor1M_SWIGUpcast(EURLibor1MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor2M_SWIGUpcast(EURLibor2MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor3M_SWIGUpcast(EURLibor3MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor4M_SWIGUpcast(EURLibor4MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor5M_SWIGUpcast(EURLibor5MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor6M_SWIGUpcast(EURLibor6MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor7M_SWIGUpcast(EURLibor7MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor8M_SWIGUpcast(EURLibor8MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor9M_SWIGUpcast(EURLibor9MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor10M_SWIGUpcast(EURLibor10MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor11M_SWIGUpcast(EURLibor11MPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT EURLiborPtr * SWIGSTDCALL CSharp_QuantLib_EURLibor1Y_SWIGUpcast(EURLibor1YPtr *jarg1) {
    return (EURLiborPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_GBPLibor_SWIGUpcast(GBPLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Jibar_SWIGUpcast(JibarPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_JPYLibor_SWIGUpcast(JPYLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_NZDLibor_SWIGUpcast(NZDLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_SEKLibor_SWIGUpcast(SEKLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Tibor_SWIGUpcast(TiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_TRLibor_SWIGUpcast(TRLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_USDLibor_SWIGUpcast(USDLiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT IborIndexPtr * SWIGSTDCALL CSharp_QuantLib_Zibor_SWIGUpcast(ZiborPtr *jarg1) {
    return (IborIndexPtr *)jarg1;
}

SWIGEXPORT OvernightIndexPtr * SWIGSTDCALL CSharp_QuantLib_Aonia_SWIGUpcast(AoniaPtr *jarg1) {
    return (OvernightIndexPtr *)jarg1;
}

SWIGEXPORT OvernightIndexPtr * SWIGSTDCALL CSharp_QuantLib_Eonia_SWIGUpcast(EoniaPtr *jarg1) {
    return (OvernightIndexPtr *)jarg1;
}

SWIGEXPORT OvernightIndexPtr * SWIGSTDCALL CSharp_QuantLib_Sonia_SWIGUpcast(SoniaPtr *jarg1) {
    return (OvernightIndexPtr *)jarg1;
}

SWIGEXPORT OvernightIndexPtr * SWIGSTDCALL CSharp_QuantLib_FedFunds_SWIGUpcast(FedFundsPtr *jarg1) {
    return (OvernightIndexPtr *)jarg1;
}

SWIGEXPORT OvernightIndexPtr * SWIGSTDCALL CSharp_QuantLib_Nzocr_SWIGUpcast(NzocrPtr *jarg1) {
    return (OvernightIndexPtr *)jarg1;
}

SWIGEXPORT SwapIndexPtr * SWIGSTDCALL CSharp_QuantLib_EuriborSwapIsdaFixA_SWIGUpcast(EuriborSwapIsdaFixAPtr *jarg1) {
    return (SwapIndexPtr *)jarg1;
}

SWIGEXPORT SwapIndexPtr * SWIGSTDCALL CSharp_QuantLib_EuriborSwapIsdaFixB_SWIGUpcast(EuriborSwapIsdaFixBPtr *jarg1) {
    return (SwapIndexPtr *)jarg1;
}

SWIGEXPORT SwapIndexPtr * SWIGSTDCALL CSharp_QuantLib_EuriborSwapIfrFix_SWIGUpcast(EuriborSwapIfrFixPtr *jarg1) {
    return (SwapIndexPtr *)jarg1;
}

SWIGEXPORT SwapIndexPtr * SWIGSTDCALL CSharp_QuantLib_EurLiborSwapIsdaFixA_SWIGUpcast(EurLiborSwapIsdaFixAPtr *jarg1) {
    return (SwapIndexPtr *)jarg1;
}

SWIGEXPORT SwapIndexPtr * SWIGSTDCALL CSharp_QuantLib_EurLiborSwapIsdaFixB_SWIGUpcast(EurLiborSwapIsdaFixBPtr *jarg1) {
    return (SwapIndexPtr *)jarg1;
}

SWIGEXPORT SwapIndexPtr * SWIGSTDCALL CSharp_QuantLib_EurLiborSwapIfrFix_SWIGUpcast(EurLiborSwapIfrFixPtr *jarg1) {
    return (SwapIndexPtr *)jarg1;
}

SWIGEXPORT Constraint * SWIGSTDCALL CSharp_QuantLib_BoundaryConstraint_SWIGUpcast(BoundaryConstraint *jarg1) {
    return (Constraint *)jarg1;
}

SWIGEXPORT Constraint * SWIGSTDCALL CSharp_QuantLib_NoConstraint_SWIGUpcast(NoConstraint *jarg1) {
    return (Constraint *)jarg1;
}

SWIGEXPORT Constraint * SWIGSTDCALL CSharp_QuantLib_PositiveConstraint_SWIGUpcast(PositiveConstraint *jarg1) {
    return (Constraint *)jarg1;
}

SWIGEXPORT Constraint * SWIGSTDCALL CSharp_QuantLib_CompositeConstraint_SWIGUpcast(CompositeConstraint *jarg1) {
    return (Constraint *)jarg1;
}

SWIGEXPORT Constraint * SWIGSTDCALL CSharp_QuantLib_NonhomogeneousBoundaryConstraint_SWIGUpcast(NonhomogeneousBoundaryConstraint *jarg1) {
    return (Constraint *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_ConjugateGradient_SWIGUpcast(ConjugateGradient *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_Simplex_SWIGUpcast(Simplex *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_SteepestDescent_SWIGUpcast(SteepestDescent *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_BFGS_SWIGUpcast(BFGS *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_LevenbergMarquardt_SWIGUpcast(LevenbergMarquardt *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_DifferentialEvolution_SWIGUpcast(DifferentialEvolution *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_GaussianSimulatedAnnealing_SWIGUpcast(GaussianSimulatedAnnealing *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_MirrorGaussianSimulatedAnnealing_SWIGUpcast(MirrorGaussianSimulatedAnnealing *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT OptimizationMethod * SWIGSTDCALL CSharp_QuantLib_LogNormalSimulatedAnnealing_SWIGUpcast(LogNormalSimulatedAnnealing *jarg1) {
    return (OptimizationMethod *)jarg1;
}

SWIGEXPORT Handle< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableBlackVolTermStructureHandle_SWIGUpcast(RelinkableHandle< BlackVolTermStructure > *jarg1) {
    return (Handle< BlackVolTermStructure > *)jarg1;
}

SWIGEXPORT Handle< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableLocalVolTermStructureHandle_SWIGUpcast(RelinkableHandle< LocalVolTermStructure > *jarg1) {
    return (Handle< LocalVolTermStructure > *)jarg1;
}

SWIGEXPORT Handle< OptionletVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableOptionletVolatilityStructureHandle_SWIGUpcast(RelinkableHandle< OptionletVolatilityStructure > *jarg1) {
    return (Handle< OptionletVolatilityStructure > *)jarg1;
}

SWIGEXPORT Handle< SwaptionVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableSwaptionVolatilityStructureHandle_SWIGUpcast(RelinkableHandle< SwaptionVolatilityStructure > *jarg1) {
    return (Handle< SwaptionVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_BlackConstantVol_SWIGUpcast(BlackConstantVolPtr *jarg1) {
    return (boost::shared_ptr< BlackVolTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_BlackVarianceCurve_SWIGUpcast(BlackVarianceCurvePtr *jarg1) {
    return (boost::shared_ptr< BlackVolTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_BlackVarianceSurface_SWIGUpcast(BlackVarianceSurfacePtr *jarg1) {
    return (boost::shared_ptr< BlackVolTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_LocalConstantVol_SWIGUpcast(LocalConstantVolPtr *jarg1) {
    return (boost::shared_ptr< LocalVolTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_LocalVolSurface_SWIGUpcast(LocalVolSurfacePtr *jarg1) {
    return (boost::shared_ptr< LocalVolTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< OptionletVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_ConstantOptionletVolatility_SWIGUpcast(ConstantOptionletVolatilityPtr *jarg1) {
    return (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< SwaptionVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_ConstantSwaptionVolatility_SWIGUpcast(ConstantSwaptionVolatilityPtr *jarg1) {
    return (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< SwaptionVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityMatrix_SWIGUpcast(SwaptionVolatilityMatrixPtr *jarg1) {
    return (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< SwaptionVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_SwaptionVolCube1_SWIGUpcast(SwaptionVolCube1Ptr *jarg1) {
    return (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< SwaptionVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_SwaptionVolCube2_SWIGUpcast(SwaptionVolCube2Ptr *jarg1) {
    return (boost::shared_ptr< SwaptionVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_SWIGUpcast(StochasticProcess1DPtr *jarg1) {
    return (boost::shared_ptr< StochasticProcess > *)jarg1;
}

SWIGEXPORT StochasticProcess1DPtr * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_SWIGUpcast(GeneralizedBlackScholesProcessPtr *jarg1) {
    return (StochasticProcess1DPtr *)jarg1;
}

SWIGEXPORT GeneralizedBlackScholesProcessPtr * SWIGSTDCALL CSharp_QuantLib_BlackScholesProcess_SWIGUpcast(BlackScholesProcessPtr *jarg1) {
    return (GeneralizedBlackScholesProcessPtr *)jarg1;
}

SWIGEXPORT GeneralizedBlackScholesProcessPtr * SWIGSTDCALL CSharp_QuantLib_BlackScholesMertonProcess_SWIGUpcast(BlackScholesMertonProcessPtr *jarg1) {
    return (GeneralizedBlackScholesProcessPtr *)jarg1;
}

SWIGEXPORT GeneralizedBlackScholesProcessPtr * SWIGSTDCALL CSharp_QuantLib_BlackProcess_SWIGUpcast(BlackProcessPtr *jarg1) {
    return (GeneralizedBlackScholesProcessPtr *)jarg1;
}

SWIGEXPORT GeneralizedBlackScholesProcessPtr * SWIGSTDCALL CSharp_QuantLib_GarmanKohlagenProcess_SWIGUpcast(GarmanKohlagenProcessPtr *jarg1) {
    return (GeneralizedBlackScholesProcessPtr *)jarg1;
}

SWIGEXPORT StochasticProcess1DPtr * SWIGSTDCALL CSharp_QuantLib_Merton76Process_SWIGUpcast(Merton76ProcessPtr *jarg1) {
    return (StochasticProcess1DPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_StochasticProcessArray_SWIGUpcast(StochasticProcessArrayPtr *jarg1) {
    return (boost::shared_ptr< StochasticProcess > *)jarg1;
}

SWIGEXPORT StochasticProcess1DPtr * SWIGSTDCALL CSharp_QuantLib_GeometricBrownianMotionProcess_SWIGUpcast(GeometricBrownianMotionProcessPtr *jarg1) {
    return (StochasticProcess1DPtr *)jarg1;
}

SWIGEXPORT StochasticProcess1DPtr * SWIGSTDCALL CSharp_QuantLib_VarianceGammaProcess_SWIGUpcast(VarianceGammaProcessPtr *jarg1) {
    return (StochasticProcess1DPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_HestonProcess_SWIGUpcast(HestonProcessPtr *jarg1) {
    return (boost::shared_ptr< StochasticProcess > *)jarg1;
}

SWIGEXPORT HestonProcessPtr * SWIGSTDCALL CSharp_QuantLib_BatesProcess_SWIGUpcast(BatesProcessPtr *jarg1) {
    return (HestonProcessPtr *)jarg1;
}

SWIGEXPORT StochasticProcess1DPtr * SWIGSTDCALL CSharp_QuantLib_HullWhiteProcess_SWIGUpcast(HullWhiteProcessPtr *jarg1) {
    return (StochasticProcess1DPtr *)jarg1;
}

SWIGEXPORT StochasticProcess1DPtr * SWIGSTDCALL CSharp_QuantLib_HullWhiteForwardProcess_SWIGUpcast(HullWhiteForwardProcessPtr *jarg1) {
    return (StochasticProcess1DPtr *)jarg1;
}

SWIGEXPORT StochasticProcess1DPtr * SWIGSTDCALL CSharp_QuantLib_GsrProcess_SWIGUpcast(GsrProcessPtr *jarg1) {
    return (StochasticProcess1DPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Stock_SWIGUpcast(StockPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_CompositeInstrument_SWIGUpcast(CompositeInstrumentPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_SimpleCashFlow_SWIGUpcast(SimpleCashFlowPtr *jarg1) {
    return (boost::shared_ptr< CashFlow > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_Redemption_SWIGUpcast(RedemptionPtr *jarg1) {
    return (boost::shared_ptr< CashFlow > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_AmortizingPayment_SWIGUpcast(AmortizingPaymentPtr *jarg1) {
    return (boost::shared_ptr< CashFlow > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_Coupon_SWIGUpcast(CouponPtr *jarg1) {
    return (boost::shared_ptr< CashFlow > *)jarg1;
}

SWIGEXPORT CouponPtr * SWIGSTDCALL CSharp_QuantLib_FixedRateCoupon_SWIGUpcast(FixedRateCouponPtr *jarg1) {
    return (CouponPtr *)jarg1;
}

SWIGEXPORT CouponPtr * SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_SWIGUpcast(FloatingRateCouponPtr *jarg1) {
    return (CouponPtr *)jarg1;
}

SWIGEXPORT FloatingRateCouponPtr * SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_SWIGUpcast(CappedFlooredCouponPtr *jarg1) {
    return (FloatingRateCouponPtr *)jarg1;
}

SWIGEXPORT FloatingRateCouponPtr * SWIGSTDCALL CSharp_QuantLib_IborCoupon_SWIGUpcast(IborCouponPtr *jarg1) {
    return (FloatingRateCouponPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< FloatingRateCouponPricer > * SWIGSTDCALL CSharp_QuantLib_IborCouponPricer_SWIGUpcast(IborCouponPricerPtr *jarg1) {
    return (boost::shared_ptr< FloatingRateCouponPricer > *)jarg1;
}

SWIGEXPORT IborCouponPricerPtr * SWIGSTDCALL CSharp_QuantLib_BlackIborCouponPricer_SWIGUpcast(BlackIborCouponPricerPtr *jarg1) {
    return (IborCouponPricerPtr *)jarg1;
}

SWIGEXPORT FloatingRateCouponPtr * SWIGSTDCALL CSharp_QuantLib_CmsCoupon_SWIGUpcast(CmsCouponPtr *jarg1) {
    return (FloatingRateCouponPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< FloatingRateCouponPricer > * SWIGSTDCALL CSharp_QuantLib_CmsCouponPricer_SWIGUpcast(CmsCouponPricerPtr *jarg1) {
    return (boost::shared_ptr< FloatingRateCouponPricer > *)jarg1;
}

SWIGEXPORT CmsCouponPricerPtr * SWIGSTDCALL CSharp_QuantLib_AnalyticHaganPricer_SWIGUpcast(AnalyticHaganPricerPtr *jarg1) {
    return (CmsCouponPricerPtr *)jarg1;
}

SWIGEXPORT CmsCouponPricerPtr * SWIGSTDCALL CSharp_QuantLib_NumericHaganPricer_SWIGUpcast(NumericHaganPricerPtr *jarg1) {
    return (CmsCouponPricerPtr *)jarg1;
}

SWIGEXPORT CappedFlooredCouponPtr * SWIGSTDCALL CSharp_QuantLib_CappedFlooredCmsCoupon_SWIGUpcast(CappedFlooredCmsCouponPtr *jarg1) {
    return (CappedFlooredCouponPtr *)jarg1;
}

SWIGEXPORT CmsCouponPricerPtr * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricer_SWIGUpcast(LinearTsrPricerPtr *jarg1) {
    return (CmsCouponPricerPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CalibrationHelper > * SWIGSTDCALL CSharp_QuantLib_SwaptionHelper_SWIGUpcast(SwaptionHelperPtr *jarg1) {
    return (boost::shared_ptr< CalibrationHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CalibrationHelper > * SWIGSTDCALL CSharp_QuantLib_CapHelper_SWIGUpcast(CapHelperPtr *jarg1) {
    return (boost::shared_ptr< CalibrationHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CalibrationHelper > * SWIGSTDCALL CSharp_QuantLib_HestonModelHelper_SWIGUpcast(HestonModelHelperPtr *jarg1) {
    return (boost::shared_ptr< CalibrationHelper > *)jarg1;
}

SWIGEXPORT Handle< CalibratedModel > * SWIGSTDCALL CSharp_QuantLib_RelinkableCalibratedModelHandle_SWIGUpcast(RelinkableHandle< CalibratedModel > *jarg1) {
    return (Handle< CalibratedModel > *)jarg1;
}

SWIGEXPORT Parameter * SWIGSTDCALL CSharp_QuantLib_ConstantParameter_SWIGUpcast(ConstantParameter *jarg1) {
    return (Parameter *)jarg1;
}

SWIGEXPORT Parameter * SWIGSTDCALL CSharp_QuantLib_NullParameter_SWIGUpcast(NullParameter *jarg1) {
    return (Parameter *)jarg1;
}

SWIGEXPORT Parameter * SWIGSTDCALL CSharp_QuantLib_PiecewiseConstantParameter_SWIGUpcast(PiecewiseConstantParameter *jarg1) {
    return (Parameter *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_VanillaOption_SWIGUpcast(VanillaOptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT VanillaOptionPtr * SWIGSTDCALL CSharp_QuantLib_EuropeanOption_SWIGUpcast(EuropeanOptionPtr *jarg1) {
    return (VanillaOptionPtr *)jarg1;
}

SWIGEXPORT VanillaOptionPtr * SWIGSTDCALL CSharp_QuantLib_ForwardVanillaOption_SWIGUpcast(ForwardVanillaOptionPtr *jarg1) {
    return (VanillaOptionPtr *)jarg1;
}

SWIGEXPORT VanillaOptionPtr * SWIGSTDCALL CSharp_QuantLib_QuantoVanillaOption_SWIGUpcast(QuantoVanillaOptionPtr *jarg1) {
    return (VanillaOptionPtr *)jarg1;
}

SWIGEXPORT QuantoVanillaOptionPtr * SWIGSTDCALL CSharp_QuantLib_QuantoForwardVanillaOption_SWIGUpcast(QuantoForwardVanillaOptionPtr *jarg1) {
    return (QuantoVanillaOptionPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_MultiAssetOption_SWIGUpcast(MultiAssetOptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticEuropeanEngine_SWIGUpcast(AnalyticEuropeanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CalibratedModel > * SWIGSTDCALL CSharp_QuantLib_HestonModel_SWIGUpcast(HestonModelPtr *jarg1) {
    return (boost::shared_ptr< CalibratedModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CalibratedModel > * SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_SWIGUpcast(PiecewiseTimeDependentHestonModelPtr *jarg1) {
    return (boost::shared_ptr< CalibratedModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_SWIGUpcast(AnalyticHestonEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticPTDHestonEngine_SWIGUpcast(AnalyticPTDHestonEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT HestonModelPtr * SWIGSTDCALL CSharp_QuantLib_BatesModel_SWIGUpcast(BatesModelPtr *jarg1) {
    return (HestonModelPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BatesEngine_SWIGUpcast(BatesEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_IntegralEngine_SWIGUpcast(IntegralEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FDBermudanEngine_SWIGUpcast(FDBermudanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FDEuropeanEngine_SWIGUpcast(FDEuropeanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialVanillaEngine_SWIGUpcast(BinomialVanillaEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCEuropeanEngine_SWIGUpcast(MCEuropeanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FDAmericanEngine_SWIGUpcast(FDAmericanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBlackScholesVanillaEngine_SWIGUpcast(FdBlackScholesVanillaEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBatesVanillaEngine_SWIGUpcast(FdBatesVanillaEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_ContinuousArithmeticAsianLevyEngine_SWIGUpcast(ContinuousArithmeticAsianLevyEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBlackScholesAsianEngine_SWIGUpcast(FdBlackScholesAsianEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FDShoutEngine_SWIGUpcast(FDShoutEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BaroneAdesiWhaleyEngine_SWIGUpcast(BaroneAdesiWhaleyApproximationEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BjerksundStenslandEngine_SWIGUpcast(BjerksundStenslandApproximationEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDigitalAmericanEngine_SWIGUpcast(AnalyticDigitalAmericanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDigitalAmericanKOEngine_SWIGUpcast(AnalyticDigitalAmericanKOEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_SWIGUpcast(DividendVanillaOptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDividendEuropeanEngine_SWIGUpcast(AnalyticDividendEuropeanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FDDividendEuropeanEngine_SWIGUpcast(FDDividendEuropeanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FDDividendAmericanEngine_SWIGUpcast(FDDividendAmericanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_BarrierOption_SWIGUpcast(BarrierOptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticBarrierEngine_SWIGUpcast(AnalyticBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCBarrierEngine_SWIGUpcast(MCBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBlackScholesBarrierEngine_SWIGUpcast(FdBlackScholesBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticBinaryBarrierEngine_SWIGUpcast(AnalyticBinaryBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialBarrierEngine_SWIGUpcast(BinomialBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_ForwardEuropeanEngine_SWIGUpcast(ForwardEuropeanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_QuantoEuropeanEngine_SWIGUpcast(QuantoEuropeanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_QuantoForwardEuropeanEngine_SWIGUpcast(QuantoForwardEuropeanEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_SWIGUpcast(ContinuousAveragingAsianOptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_SWIGUpcast(DiscreteAveragingAsianOptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticContinuousGeometricAveragePriceAsianEngine_SWIGUpcast(AnalyticContinuousGeometricAveragePriceAsianEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDiscreteGeometricAveragePriceAsianEngine_SWIGUpcast(AnalyticDiscreteGeometricAveragePriceAsianEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDiscreteGeometricAverageStrikeAsianEngine_SWIGUpcast(AnalyticDiscreteGeometricAverageStrikeAsianEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCDiscreteArithmeticAPEngine_SWIGUpcast(MCDiscreteArithmeticAPEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCDiscreteArithmeticASEngine_SWIGUpcast(MCDiscreteArithmeticASEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCDiscreteGeometricAPEngine_SWIGUpcast(MCDiscreteGeometricAPEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_VarianceGammaEngine_SWIGUpcast(VarianceGammaEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FFTVarianceGammaEngine_SWIGUpcast(FFTVarianceGammaEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_SWIGUpcast(DoubleBarrierOptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT DoubleBarrierOptionPtr * SWIGSTDCALL CSharp_QuantLib_QuantoDoubleBarrierOption_SWIGUpcast(QuantoDoubleBarrierOptionPtr *jarg1) {
    return (DoubleBarrierOptionPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDoubleBarrierEngine_SWIGUpcast(AnalyticDoubleBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_WulinYongDoubleBarrierEngine_SWIGUpcast(WulinYongDoubleBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT Handle< DeltaVolQuote > * SWIGSTDCALL CSharp_QuantLib_RelinkableDeltaVolQuoteHandle_SWIGUpcast(RelinkableHandle< DeltaVolQuote > *jarg1) {
    return (Handle< DeltaVolQuote > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_VannaVolgaDoubleBarrierEngine_SWIGUpcast(VannaVolgaDoubleBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDoubleBarrierBinaryEngine_SWIGUpcast(AnalyticDoubleBarrierBinaryEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialDoubleBarrierEngine_SWIGUpcast(BinomialDoubleBarrierEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_PlainVanillaPayoff_SWIGUpcast(PlainVanillaPayoffPtr *jarg1) {
    return (boost::shared_ptr< Payoff > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_PercentageStrikePayoff_SWIGUpcast(PercentageStrikePayoffPtr *jarg1) {
    return (boost::shared_ptr< Payoff > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_CashOrNothingPayoff_SWIGUpcast(CashOrNothingPayoffPtr *jarg1) {
    return (boost::shared_ptr< Payoff > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_AssetOrNothingPayoff_SWIGUpcast(AssetOrNothingPayoffPtr *jarg1) {
    return (boost::shared_ptr< Payoff > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_SuperSharePayoff_SWIGUpcast(SuperSharePayoffPtr *jarg1) {
    return (boost::shared_ptr< Payoff > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_GapPayoff_SWIGUpcast(GapPayoffPtr *jarg1) {
    return (boost::shared_ptr< Payoff > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_BasketPayoff_SWIGUpcast(BasketPayoffPtr *jarg1) {
    return (boost::shared_ptr< Payoff > *)jarg1;
}

SWIGEXPORT BasketPayoffPtr * SWIGSTDCALL CSharp_QuantLib_MinBasketPayoff_SWIGUpcast(MinBasketPayoffPtr *jarg1) {
    return (BasketPayoffPtr *)jarg1;
}

SWIGEXPORT BasketPayoffPtr * SWIGSTDCALL CSharp_QuantLib_MaxBasketPayoff_SWIGUpcast(MaxBasketPayoffPtr *jarg1) {
    return (BasketPayoffPtr *)jarg1;
}

SWIGEXPORT BasketPayoffPtr * SWIGSTDCALL CSharp_QuantLib_AverageBasketPayoff_SWIGUpcast(AverageBasketPayoffPtr *jarg1) {
    return (BasketPayoffPtr *)jarg1;
}

SWIGEXPORT MultiAssetOptionPtr * SWIGSTDCALL CSharp_QuantLib_BasketOption_SWIGUpcast(BasketOptionPtr *jarg1) {
    return (MultiAssetOptionPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCEuropeanBasketEngine_SWIGUpcast(MCEuropeanBasketEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCAmericanBasketEngine_SWIGUpcast(MCAmericanBasketEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_StulzEngine_SWIGUpcast(StulzEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT MultiAssetOptionPtr * SWIGSTDCALL CSharp_QuantLib_EverestOption_SWIGUpcast(EverestOptionPtr *jarg1) {
    return (MultiAssetOptionPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCEverestEngine_SWIGUpcast(MCEverestEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT MultiAssetOptionPtr * SWIGSTDCALL CSharp_QuantLib_HimalayaOption_SWIGUpcast(HimalayaOptionPtr *jarg1) {
    return (MultiAssetOptionPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCHimalayaEngine_SWIGUpcast(MCHimalayaEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Callability > * SWIGSTDCALL CSharp_QuantLib_SoftCallability_SWIGUpcast(SoftCallabilityPtr *jarg1) {
    return (boost::shared_ptr< Callability > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Seasonality > * SWIGSTDCALL CSharp_QuantLib_MultiplicativePriceSeasonalityPtr_SWIGUpcast(MultiplicativePriceSeasonalityPtr *jarg1) {
    return (boost::shared_ptr< Seasonality > *)jarg1;
}

SWIGEXPORT Handle< YoYInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableYoYInflationTermStructureHandle_SWIGUpcast(RelinkableHandle< YoYInflationTermStructure > *jarg1) {
    return (Handle< YoYInflationTermStructure > *)jarg1;
}

SWIGEXPORT Handle< ZeroInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableZeroInflationTermStructureHandle_SWIGUpcast(RelinkableHandle< ZeroInflationTermStructure > *jarg1) {
    return (Handle< ZeroInflationTermStructure > *)jarg1;
}

SWIGEXPORT Region * SWIGSTDCALL CSharp_QuantLib_CustomRegion_SWIGUpcast(CustomRegion *jarg1) {
    return (Region *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Index > * SWIGSTDCALL CSharp_QuantLib_InflationIndex_SWIGUpcast(InflationIndexPtr *jarg1) {
    return (boost::shared_ptr< Index > *)jarg1;
}

SWIGEXPORT InflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_ZeroInflationIndex_SWIGUpcast(ZeroInflationIndexPtr *jarg1) {
    return (InflationIndexPtr *)jarg1;
}

SWIGEXPORT InflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_YoYInflationIndex_SWIGUpcast(YoYInflationIndexPtr *jarg1) {
    return (InflationIndexPtr *)jarg1;
}

SWIGEXPORT ZeroInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_EUHICP_SWIGUpcast(EUHICPPtr *jarg1) {
    return (ZeroInflationIndexPtr *)jarg1;
}

SWIGEXPORT ZeroInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_EUHICPXT_SWIGUpcast(EUHICPXTPtr *jarg1) {
    return (ZeroInflationIndexPtr *)jarg1;
}

SWIGEXPORT ZeroInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_FRHICP_SWIGUpcast(FRHICPPtr *jarg1) {
    return (ZeroInflationIndexPtr *)jarg1;
}

SWIGEXPORT ZeroInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_UKRPI_SWIGUpcast(UKRPIPtr *jarg1) {
    return (ZeroInflationIndexPtr *)jarg1;
}

SWIGEXPORT ZeroInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_USCPI_SWIGUpcast(USCPIPtr *jarg1) {
    return (ZeroInflationIndexPtr *)jarg1;
}

SWIGEXPORT ZeroInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_ZACPI_SWIGUpcast(ZACPIPtr *jarg1) {
    return (ZeroInflationIndexPtr *)jarg1;
}

SWIGEXPORT YoYInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_YYEUHICP_SWIGUpcast(YYEUHICPPtr *jarg1) {
    return (YoYInflationIndexPtr *)jarg1;
}

SWIGEXPORT YoYInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_YYEUHICPXT_SWIGUpcast(YYEUHICPXTPtr *jarg1) {
    return (YoYInflationIndexPtr *)jarg1;
}

SWIGEXPORT YoYInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_YYFRHICP_SWIGUpcast(YYFRHICPPtr *jarg1) {
    return (YoYInflationIndexPtr *)jarg1;
}

SWIGEXPORT YoYInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_YYUKRPI_SWIGUpcast(YYUKRPIPtr *jarg1) {
    return (YoYInflationIndexPtr *)jarg1;
}

SWIGEXPORT YoYInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_YYUSCPI_SWIGUpcast(YYUSCPIPtr *jarg1) {
    return (YoYInflationIndexPtr *)jarg1;
}

SWIGEXPORT YoYInflationIndexPtr * SWIGSTDCALL CSharp_QuantLib_YYZACPI_SWIGUpcast(YYZACPIPtr *jarg1) {
    return (YoYInflationIndexPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< ZeroHelper > * SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwapHelper_SWIGUpcast(ZeroCouponInflationSwapHelperPtr *jarg1) {
    return (boost::shared_ptr< ZeroHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YoYHelper > * SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwapHelper_SWIGUpcast(YearOnYearInflationSwapHelperPtr *jarg1) {
    return (boost::shared_ptr< YoYHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< ZeroInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseZeroInflation_SWIGUpcast(PiecewiseZeroInflationPtr *jarg1) {
    return (boost::shared_ptr< ZeroInflationTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YoYInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseYoYInflation_SWIGUpcast(PiecewiseYoYInflationPtr *jarg1) {
    return (boost::shared_ptr< YoYInflationTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_SWIGUpcast(ZeroCouponInflationSwapPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_SWIGUpcast(YearOnYearInflationSwapPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_YoYInflationCapFloor_SWIGUpcast(YoYInflationCapFloorPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT YoYInflationCapFloorPtr * SWIGSTDCALL CSharp_QuantLib_YoYInflationCap_SWIGUpcast(YoYInflationCapPtr *jarg1) {
    return (YoYInflationCapFloorPtr *)jarg1;
}

SWIGEXPORT YoYInflationCapFloorPtr * SWIGSTDCALL CSharp_QuantLib_YoYInflationFloor_SWIGUpcast(YoYInflationFloorPtr *jarg1) {
    return (YoYInflationCapFloorPtr *)jarg1;
}

SWIGEXPORT YoYInflationCapFloorPtr * SWIGSTDCALL CSharp_QuantLib_YoYInflationCollar_SWIGUpcast(YoYInflationCollarPtr *jarg1) {
    return (YoYInflationCapFloorPtr *)jarg1;
}

SWIGEXPORT Handle< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_RelinkableShortRateModelHandle_SWIGUpcast(RelinkableHandle< ShortRateModel > *jarg1) {
    return (Handle< ShortRateModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_Vasicek_SWIGUpcast(VasicekPtr *jarg1) {
    return (boost::shared_ptr< ShortRateModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_HullWhite_SWIGUpcast(HullWhitePtr *jarg1) {
    return (boost::shared_ptr< ShortRateModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_BlackKarasinski_SWIGUpcast(BlackKarasinskiPtr *jarg1) {
    return (boost::shared_ptr< ShortRateModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_G2_SWIGUpcast(G2Ptr *jarg1) {
    return (boost::shared_ptr< ShortRateModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_JamshidianSwaptionEngine_SWIGUpcast(JamshidianSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_TreeSwaptionEngine_SWIGUpcast(TreeSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticCapFloorEngine_SWIGUpcast(AnalyticCapFloorEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_TreeCapFloorEngine_SWIGUpcast(TreeCapFloorEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_G2SwaptionEngine_SWIGUpcast(G2SwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdG2SwaptionEngine_SWIGUpcast(FdG2SwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdHullWhiteSwaptionEngine_SWIGUpcast(FdHullWhiteSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Bond_SWIGUpcast(BondPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_ZeroCouponBond_SWIGUpcast(ZeroCouponBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_FixedRateBond_SWIGUpcast(FixedRateBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_FloatingRateBond_SWIGUpcast(FloatingRateBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_CmsRateBond_SWIGUpcast(CmsRateBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_DiscountingBondEngine_SWIGUpcast(DiscountingBondEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_SWIGUpcast(CallableFixedRateBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_TreeCallableFixedRateBondEngine_SWIGUpcast(TreeCallableFixedRateBondEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BlackCallableFixedRateBondEngine_SWIGUpcast(BlackCallableFixedRateBondEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_CPIBond_SWIGUpcast(CPIBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_CapFloor_SWIGUpcast(CapFloorPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT CapFloorPtr * SWIGSTDCALL CSharp_QuantLib_Cap_SWIGUpcast(CapPtr *jarg1) {
    return (CapFloorPtr *)jarg1;
}

SWIGEXPORT CapFloorPtr * SWIGSTDCALL CSharp_QuantLib_Floor_SWIGUpcast(FloorPtr *jarg1) {
    return (CapFloorPtr *)jarg1;
}

SWIGEXPORT CapFloorPtr * SWIGSTDCALL CSharp_QuantLib_Collar_SWIGUpcast(CollarPtr *jarg1) {
    return (CapFloorPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BlackCapFloorEngine_SWIGUpcast(BlackCapFloorEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BachelierCapFloorEngine_SWIGUpcast(BachelierCapFloorEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Dividend > * SWIGSTDCALL CSharp_QuantLib_FixedDividend_SWIGUpcast(FixedDividendPtr *jarg1) {
    return (boost::shared_ptr< Dividend > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Dividend > * SWIGSTDCALL CSharp_QuantLib_FractionalDividend_SWIGUpcast(FractionalDividendPtr *jarg1) {
    return (boost::shared_ptr< Dividend > *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_ConvertibleZeroCouponBond_SWIGUpcast(ConvertibleZeroCouponBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_ConvertibleFixedCouponBond_SWIGUpcast(ConvertibleFixedCouponBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT BondPtr * SWIGSTDCALL CSharp_QuantLib_ConvertibleFloatingRateBond_SWIGUpcast(ConvertibleFloatingRateBondPtr *jarg1) {
    return (BondPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialConvertibleEngine_SWIGUpcast(BinomialConvertibleEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT Handle< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableDefaultProbabilityTermStructureHandle_SWIGUpcast(RelinkableHandle< DefaultProbabilityTermStructure > *jarg1) {
    return (Handle< DefaultProbabilityTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_FlatHazardRate_SWIGUpcast(FlatHazardRatePtr *jarg1) {
    return (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_HazardRateCurve_SWIGUpcast(HazardRateCurvePtr *jarg1) {
    return (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_DefaultDensityCurve_SWIGUpcast(DefaultDensityCurvePtr *jarg1) {
    return (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< DefaultProbabilityHelper > * SWIGSTDCALL CSharp_QuantLib_SpreadCdsHelper_SWIGUpcast(SpreadCdsHelperPtr *jarg1) {
    return (boost::shared_ptr< DefaultProbabilityHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< DefaultProbabilityHelper > * SWIGSTDCALL CSharp_QuantLib_UpfrontCdsHelper_SWIGUpcast(UpfrontCdsHelperPtr *jarg1) {
    return (boost::shared_ptr< DefaultProbabilityHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatHazardRate_SWIGUpcast(PiecewiseFlatHazardRatePtr *jarg1) {
    return (boost::shared_ptr< DefaultProbabilityTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_SWIGUpcast(CreditDefaultSwapPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MidPointCdsEngine_SWIGUpcast(MidPointCdsEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_IntegralCdsEngine_SWIGUpcast(IntegralCdsEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_SWIGUpcast(DiscountCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Swap_SWIGUpcast(SwapPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT SwapPtr * SWIGSTDCALL CSharp_QuantLib_VanillaSwap_SWIGUpcast(VanillaSwapPtr *jarg1) {
    return (SwapPtr *)jarg1;
}

SWIGEXPORT SwapPtr * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_SWIGUpcast(NonstandardSwapPtr *jarg1) {
    return (SwapPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_DiscountingSwapEngine_SWIGUpcast(DiscountingSwapEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT SwapPtr * SWIGSTDCALL CSharp_QuantLib_AssetSwap_SWIGUpcast(AssetSwapPtr *jarg1) {
    return (SwapPtr *)jarg1;
}

SWIGEXPORT SwapPtr * SWIGSTDCALL CSharp_QuantLib_FloatFloatSwap_SWIGUpcast(FloatFloatSwapPtr *jarg1) {
    return (SwapPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_DepositRateHelper_SWIGUpcast(DepositRateHelperPtr *jarg1) {
    return (boost::shared_ptr< RateHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_FraRateHelper_SWIGUpcast(FraRateHelperPtr *jarg1) {
    return (boost::shared_ptr< RateHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_FuturesRateHelper_SWIGUpcast(FuturesRateHelperPtr *jarg1) {
    return (boost::shared_ptr< RateHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_SwapRateHelper_SWIGUpcast(SwapRateHelperPtr *jarg1) {
    return (boost::shared_ptr< RateHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_BondHelper_SWIGUpcast(BondHelperPtr *jarg1) {
    return (boost::shared_ptr< RateHelper > *)jarg1;
}

SWIGEXPORT BondHelperPtr * SWIGSTDCALL CSharp_QuantLib_FixedRateBondHelper_SWIGUpcast(FixedRateBondHelperPtr *jarg1) {
    return (BondHelperPtr *)jarg1;
}

SWIGEXPORT boost::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_OISRateHelper_SWIGUpcast(OISRateHelperPtr *jarg1) {
    return (boost::shared_ptr< RateHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_DatedOISRateHelper_SWIGUpcast(DatedOISRateHelperPtr *jarg1) {
    return (boost::shared_ptr< RateHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_FxSwapRateHelper_SWIGUpcast(FxSwapRateHelperPtr *jarg1) {
    return (boost::shared_ptr< RateHelper > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_FittedBondDiscountCurve_SWIGUpcast(FittedBondDiscountCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT FittingMethod * SWIGSTDCALL CSharp_QuantLib_ExponentialSplinesFitting_SWIGUpcast(ExponentialSplinesFitting *jarg1) {
    return (FittingMethod *)jarg1;
}

SWIGEXPORT FittingMethod * SWIGSTDCALL CSharp_QuantLib_NelsonSiegelFitting_SWIGUpcast(NelsonSiegelFitting *jarg1) {
    return (FittingMethod *)jarg1;
}

SWIGEXPORT FittingMethod * SWIGSTDCALL CSharp_QuantLib_SvenssonFitting_SWIGUpcast(SvenssonFitting *jarg1) {
    return (FittingMethod *)jarg1;
}

SWIGEXPORT FittingMethod * SWIGSTDCALL CSharp_QuantLib_CubicBSplinesFitting_SWIGUpcast(CubicBSplinesFitting *jarg1) {
    return (FittingMethod *)jarg1;
}

SWIGEXPORT FittingMethod * SWIGSTDCALL CSharp_QuantLib_SimplePolynomialFitting_SWIGUpcast(SimplePolynomialFitting *jarg1) {
    return (FittingMethod *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ForwardCurve_SWIGUpcast(ForwardCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_ForwardRateAgreement_SWIGUpcast(ForwardRateAgreementPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Gaussian1dModel > * SWIGSTDCALL CSharp_QuantLib_Gsr_SWIGUpcast(GsrPtr *jarg1) {
    return (boost::shared_ptr< Gaussian1dModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Gaussian1dModel > * SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_SWIGUpcast(MarkovFunctionalPtr *jarg1) {
    return (boost::shared_ptr< Gaussian1dModel > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dSwaptionEngine_SWIGUpcast(Gaussian1dSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dJamshidianSwaptionEngine_SWIGUpcast(Gaussian1dJamshidianSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dNonstandardSwaptionEngine_SWIGUpcast(Gaussian1dNonstandardSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dFloatFloatSwaptionEngine_SWIGUpcast(Gaussian1dFloatFloatSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< DefaultBoundaryCondition > * SWIGSTDCALL CSharp_QuantLib_NeumannBC_SWIGUpcast(NeumannBCPtr *jarg1) {
    return (boost::shared_ptr< DefaultBoundaryCondition > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< DefaultBoundaryCondition > * SWIGSTDCALL CSharp_QuantLib_DirichletBC_SWIGUpcast(DirichletBCPtr *jarg1) {
    return (boost::shared_ptr< DefaultBoundaryCondition > *)jarg1;
}

SWIGEXPORT TridiagonalOperator * SWIGSTDCALL CSharp_QuantLib_DPlus_SWIGUpcast(DPlus *jarg1) {
    return (TridiagonalOperator *)jarg1;
}

SWIGEXPORT TridiagonalOperator * SWIGSTDCALL CSharp_QuantLib_DMinus_SWIGUpcast(DMinus *jarg1) {
    return (TridiagonalOperator *)jarg1;
}

SWIGEXPORT TridiagonalOperator * SWIGSTDCALL CSharp_QuantLib_DZero_SWIGUpcast(DZero *jarg1) {
    return (TridiagonalOperator *)jarg1;
}

SWIGEXPORT TridiagonalOperator * SWIGSTDCALL CSharp_QuantLib_DPlusDMinus_SWIGUpcast(DPlusDMinus *jarg1) {
    return (TridiagonalOperator *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatForward_SWIGUpcast(PiecewiseFlatForwardPtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearForward_SWIGUpcast(PiecewiseLinearForwardPtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearZero_SWIGUpcast(PiecewiseLinearZeroPtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseCubicZero_SWIGUpcast(PiecewiseCubicZeroPtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogCubicDiscount_SWIGUpcast(PiecewiseLogCubicDiscountPtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT Statistics * SWIGSTDCALL CSharp_QuantLib_RiskStatistics_SWIGUpcast(RiskStatistics *jarg1) {
    return (Statistics *)jarg1;
}

SWIGEXPORT Handle< CapFloorTermVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableCapFloorTermVolatilityStructureHandle_SWIGUpcast(RelinkableHandle< CapFloorTermVolatilityStructure > *jarg1) {
    return (Handle< CapFloorTermVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CapFloorTermVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolCurve_SWIGUpcast(CapFloorTermVolCurvePtr *jarg1) {
    return (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< CapFloorTermVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolSurface_SWIGUpcast(CapFloorTermVolSurfacePtr *jarg1) {
    return (boost::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< StrippedOptionletBase > * SWIGSTDCALL CSharp_QuantLib_OptionletStripper1_SWIGUpcast(OptionletStripper1Ptr *jarg1) {
    return (boost::shared_ptr< StrippedOptionletBase > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< OptionletVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletAdapter_SWIGUpcast(StrippedOptionletAdapterPtr *jarg1) {
    return (boost::shared_ptr< OptionletVolatilityStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Swaption_SWIGUpcast(SwaptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_NonstandardSwaption_SWIGUpcast(NonstandardSwaptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_FloatFloatSwaption_SWIGUpcast(FloatFloatSwaptionPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BlackSwaptionEngine_SWIGUpcast(BlackSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BachelierSwaptionEngine_SWIGUpcast(BachelierSwaptionEnginePtr *jarg1) {
    return (boost::shared_ptr< PricingEngine > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_SWIGUpcast(ZeroCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_SWIGUpcast(LogLinearZeroCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_SWIGUpcast(CubicZeroCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_SWIGUpcast(LogCubicZeroCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ForwardFlatZeroCurve_SWIGUpcast(ForwardFlatZeroCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_BackwardFlatZeroCurve_SWIGUpcast(BackwardFlatZeroCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_SWIGUpcast(MonotonicCubicZeroCurvePtr *jarg1) {
    return (boost::shared_ptr< YieldTermStructure > *)jarg1;
}

SWIGEXPORT boost::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Forward_SWIGUpcast(ForwardPtr *jarg1) {
    return (boost::shared_ptr< Instrument > *)jarg1;
}

SWIGEXPORT ForwardPtr * SWIGSTDCALL CSharp_QuantLib_FixedRateBondForward_SWIGUpcast(FixedRateBondForwardPtr *jarg1) {
    return (ForwardPtr *)jarg1;
}

#ifdef __cplusplus
}
#endif

